TaskList in Visual Studio - Making it better

It was great to come across a new feature in Visual Studio - The TaskList. Well, yes it isn't new but, it certainly was new to me. I had never really come across this wonderful feature until last week when secretGeek blogged that code would suck less if the compiler could raise an error when a // TODO token was detected. A comment from Goran indicated that it was completely possible with the current versions of Visual Studio.

A //TODO: token.
Are shown in VS if you click TaskList. Couldn’t live without this one :)

Yeah, sure. Can’t live without it. Although the compiler doesn’t throw you an error, it indicates all parts of code where such tokens appear and hence can be taken care of easily.

How To Use
You can use the TaskList comments for:

• Features to be added
• Problems to be corrected
• Classes to implement
• Place-markers for error handling code
• Reminders to check in the file

Add your comment in the code preceded by the token.    

Once done, open up the TaskList from the View menu.

Once the TaskList is up you will see something like this.

The TaskList also allows custom tokens to be included. Go to Tools –> Options –> Environment –> TaskList.

User Tasks
You can add your own tasks in the TaskList by selecting the ‘User Tasks’ selection from the dropdown list on the TaskList toolbox. These tasks aren’t associated with code, but will allow users to add their own high level tasks.

Extending the TaskList
I would like to see the following additional options in the TaskList:

• Task Alarms – which would associate an alarm with a high priority comment to help just in case you forget to take care.
• User Tasks to be more specific (by having a file anchor like ‘Comments’) to allow user tasks to be associated with a particular line in code.

And no, I’m not waiting on Microsoft to extend it in some other version of Visual Studio. I’m starting right away to write a package that would do this for me, hopefully.

More Things to Remember
With Visual Basic projects, the Task List displays all of the comments in the project. With Visual C# and Visual J# projects, the Task List displays only the comments that are found in the files currently opened for edit. With Visual C++ projects, the Task List displays only the comments that are found in the file currently active in the editor.

C# 3.0 for Beginners - Extension Methods - Part 2

Custom Extension Methods

C# 3.0 enables you with the ability to extend the functionality of existing types. This means that you can write your own extension methods that would give the programmer the feeling that those are just methods provided by the existing type.

For example, System.Int32 doesn't provide you an IsEven() method which would tell you if the integer is holding an even value. It would obviously be great if you could write a method which does this, just in case you use this functionality heavily in your code. You would then write a method like this

public bool IsEven(Int32 i)
{
    if(i%2 == 0)
    {
        return true;
    }
    else
    {
        return false;
    }
}

Well, that's perfectly fine. But, I wish we could make it more easier. And I bet we can for sure, that's what extension methods are here for. No, we cannot go and implement the IsEven() method for the Int32 type, but C# 3.0 allows you to extend type functionality in a different way.

Check out the following code. I'm extending the Int32 type to expose the Int32.IsEven() extension method.

public static class MyIntegerExtensionMethod
{
    public static bool IsEven(this Int32 i)
    {
        if (i % 2 == 0)
        {
            return true;
        }
        else
        {
            return false;
        }
    }
}

public class Program
{
    static void Main(string[] args)
    {
        Int32 n = 9;
        Console.WriteLine(n.IsEven());
    }
}

Let's look at the most important part, the method signature.

public static bool IsEven(this Int32 i)

A template for the above would be

<access_modifier> static <return_type> Method_Name(this <extended_type> <instance_of_type>, <args_list>)

While <access_modifer> and <return_type> are intuitive, special attention is needed at the parameters of the method. The first parameter resembles the type which is to be extended, preceded with the 'this' keyword. The arguments that follow are the actual arguments/parameters to the method.

Another thing to remember is that extension methods should be defined as static members in a static class. The only difference between a normal method and an extension method is that the first parameter of an extension is always prefixed with the 'this' keyword. The rest are normal parameters. Also, when using the extension method you should remember to keep the extension method within the scope of its usage or you could even include it using the 'using' directive.

Usage Restrictions

• Extension methods can access only the public members of the type being extended.
• If you define an extension method whose signature matches with the method already existing in the extended type, priority is given to the existing method and the new extension method is ignored.

Have fun with this great feature!

C# 3.0 for Beginners - Extension Methods - Part 1

All C# code is eventually executed by the .NET CLR. This requires the C# compiler to transform the LINQ query expressions to a format that is understandable by .NET. LINQ query expressions are transformed into method calls, which are called extension methods. These methods are slightly different from normal methods. Lets discuss them in more detail:

Consider the example that we saw in my previous posts.

    public static void GetIExplorer()
    {
        //  1. Data Source
        Process[] processes = Process.GetProcesses();

        //  2. Query Creation
        IEnumerable<int> query =
              from p in processes
              where p.ProcessName.ToLower().Equals("iexplore")
              select p.Id;

        //  3. Query execution
        foreach (int pid in query)
        {
            Console.WriteLine("Process Id : "+pid);
        }
    }

The query creation in part two transforms in a series of method calls on the data source 'processes' as follows.

    IEnumerable<int> query =
            processes.Where(p => p.ProcessName.ToLower().Equals("iexplore"))
                     .Select(p => p.Id);

The Select clause, however, it not essential. It may be ignored and you might retrieve a list of processes and not their process Ids. The Select clause here specifies the entity to be selected in detail, in the above example, it was the process id belonging to the selected process.

Now, you might wonder that since the Where() method was called on the 'processes' Array, the Array object might have implemented the Where() method. But, that's not quite the case here. The method Where() is called an extension method and is used for extending a type's functionality.

We have also made use of lambda expressions here. We will discuss their significance later in detail, but, for now, you can look at it as if it were a provision to select entities based in certain specified conditions. In the above code the variable 'p' indicates each element in the 'processes' array which is subjected to an expression evaluation (p.ProcessName.ToLower().Equals("iexplore")), and only if the result of the condition evaluation is true, will the item be selected as the result of the query. These are filtering expressions.

In my next post I will describe how to define and use your own extension methods.

C# 3.0 for Beginners - Query Execution in LINQ

The execution of queries written is different from what a new LINQ user would perceive it to be. The query isn’t evaluated and the result is not stored in the query variable until the foreach iteration (where the values are actually required) or a manual iteration using the underlying GetEnumerator and MoveNext methods. The query variable only stores the query commands. This is concept is referred to as deferred execution.

public static void GetIExplorer()
{
    //  1. Data Source
    Process[] processes = Process.GetProcesses();

    //  2. Query Creation
    IEnumerable<int> query =
       from p in processes
       where p.ProcessName.ToLower().Equals("iexplore")
       select p.Id;

    //  3. Query execution
    //  This is the part where the query is evaluated
    //  and result is stored in the query variable.
    foreach (int pid in query)
    {
        Console.WriteLine("Process Id : "+pid);
    }
}

As the query variable doesn’t store the results, you can execute it as many times as you like. If a data source is updated at regular intervals, you could retrieve the latest results every time you iterate over the query variable.

The figure shown above shows information about the query variable ‘query’. The Results View section shows the results of query execution and it also informs the user that “Expanding the Results View will enumerate the IEnumerable” i.e. perform the query execution for debugging.

Forcing immediate execution of queries
Immediate execution of queries is forced for queries that perform aggregation functions over the data retrieved from query evaluation. These functions include Count, Max, Min, Average etc. These queries execute without an explicit foreach statement because the query itself would use a foreach statement to calculate the result.

The following query returns the number of processes identified as “IExplore.exe”.

//  Calculate the number of "iexplore" processes
int numberOfProcesses = query.Count();

Execution results can be cached (if need be) for temporary processing using the ToList() and ToArray() methods as shown below:

//  Caching results using ToList() and ToArray() methods.
List<int> queryResult =
(from p in processes
    where p.ProcessName.ToLower().Equals("iexplore")
    select p.Id).ToList();

Array inferredQueryResult =
    (from p in processes
    where p.ProcessName.ToLower().Equals("iexplore")
    select p.Id).ToArray();

C# 3.0 for Beginners - Learning LINQ - An Overview

I’m probably quite late to provide an overview on LINQ, which is by now a lot more popular than the time when I actually had started hearing about it.

Well, this is expected to be a series of posts that would help other rookies like me who haven’t yet started learning LINQ yet. So, lets get started. To begin with I’m providing here an overview of LINQ (Language Integrated Query).

LINQ was introduced by Microsoft with the objective to reduce the complexity of accessing and integrating information. With the LINQ project, Microsoft has added query facilities to the .Net Framework that apply to all sources of information, not just relational or XML data. Everyday programmers write code that accesses a data source using looping and/or conditional constructs etc. The same constructs can be written using query expressions that are far lesser in code size. LINQ makes it possible to write easily readable and elegant code. The examples that follow will imply how easily understandable LINQ code can be.

LINQ defines a set of standard query operators that you can use for traversal, filter and projection operations. These standard operators can be applied to any IEnumerable<T> based information source. The set of standard query operators can be augmented with new domain-specific operators that are more suitable for the target domain or technology. This extensibility in the query architecture is used in the LINQ project itself to provide implementations that work over both XML (LINQ to XML) and SQL (LINQ to SQL) data. Lets write some code to understand the query operators in more detail:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Diagnostics;

/// <summary>
/// Using standard query operators.
/// </summary>
public static void GetIExplorer()
{
    //  1. Data Source
    Process[] processes = Process.GetProcesses();

    //  2. Query Creation
    IEnumerable<int> query = from p in processes
                             where p.ProcessName.ToLower().Equals("iexplore")
                             select p.Id;

    //  3. Query execution
    foreach (int pid in query)
    {
        Console.WriteLine("Process Id : "+pid);
    }
}

All LINQ query operations consist of three distinct operations:

Identify the data source
Query creation
Query execution

Calling the method would show you the currently running Internet Explorer processes (their process ids). The heart of the method lies in the following statement of our program.

IEnumerable<int> query = from p in processes
                         where p.ProcessName.ToLower().Equals("iexplore")
                         select p.Id;

The expression on the right hand side of this statement is called the query expression. The output of this expression is held in the local variable ‘query’. The query expression operates on one or more information sources by applying the query operators from the standard or domian specific set of query operators. We have used standard query operators here namely where and select.

The from clause select the list of processes which becomes the input for the where operator which filters the list and selects only those elements that satisfy the condition specified with the where operator. The selected elements are then processed by the select operator that determines any specific information selection for each element.

The above statement can also be written using explicit syntax as shown below:

IEnumerable<int> query = Process.GetProcesses()
               .Where(s => s.ProcessName.ToLower().Equals("iexplore"))
               .Select(s => s.Id);

This form of query is called a method-based query and the arguments to the query operators are called lambda expressions. They allow query operators to be defined individually as methods and are connected using the dot notation. I will deal with lambda expressions in my following posts.

Anonymous methods in C#

An anonymous method is just a method that has no name. Anonymous methods are most frequently used to pass a code block as a delegate parameter.

Before C# 2.0, the only way to declare a delegate was to use named methods as shown in the example below

// Create the delegate
public delegate void Display(string message);

// Create the method
public static void DisplayOnConsole(string myMessage)
{
    Console.WriteLine(myMessage);
}

public static void Main(string[] args)
{
    // Here, the delegate is instantiated with the
    // method which should be invoked.
    Display myDisplay = new Display(DisplayOnConsole);

    // Invoke
    myDisplay("Hello World!");
}

Then C# 2.0 introduced the concept of anonymous methods.

// Creation of delegate with an anonymous method
Display newDisplay = delegate(string msg)
{
    // Anonymous method body
    Console.WriteLine(msg);
};

// Invoke
newDisplay("Hello World using Anonymous methods.");

The difference here is quite apparent. Creation of a new method to act as a handler is not required; the delegate itself specifies what should be done when invoked. Anonymous methods reduce the coding overhead in instantiating delegates because you do not have to create a separate method. Specifying a code bolck instead of a delegate can be useful in situations where creation another method might seem an unnecessary overhead.

Some other points to remember:

• There cannot be any jump statements like goto, break or continue inside the code block if the target is outside the block and vice versa.
• The scope of parameters of an anonymous method is the anonymous code block.
• No unsafe code can be used within the anonymous code block.
• The local variables and parameters whose scope contains an anonymous method declaration are called outer variables of the anonymous method. 

In the following code the variable x is an outer variable.

int x = 0;
Display newDisplay = delegate(string msg)
{
    Console.WriteLine(msg + x);
};

• An anonymous method cannot access the ref or out variables of an outer scope.

C# 3.0 introduces lambda expressions which are pretty much similar to anonymous methods but more expressive and concise. Applications written using .NET Framework version 3.5 and higher should make use of lambda expressions instead of anonymous methods. I will discuss lambda expressions in detail after I start with LINQ (Language Integrated Query) in my following posts.

Did you know the two uses of ‘default’?

Well, maybe you do and maybe you don’t. And I’m not trying to start a series of posts tagged “Did you know?”, I guess Sara Ford is much better at it.

You’ve used the default keyword in C# as many times as possible in switch statements to indicate the default operation to be carried out. That’s one place where you would normally use the default keyword.

You can also use the default keyword in generic code where it specifies the default value of the type parameter which is null for reference types and zero for value types. In generic programming it is always difficult to guess what default value to assign to a parameterized type T when you don’t know information such as whether T is a value/reference type; if it’s a value type, is it an elementary type or a struct? This is where the default keyword is used to find out the exact default value for the current type. Here is how it would be used:

class MyGenerics<T>
{
    public void MyMethod()
    {
        T myVar = default(T);
     
        //...
        //...
        int defaultValue = default(int);
    }
}

The default value for reference types is null, for value types is zero and for struct types each member is initialized with it’s default value depending on whether it is a value or reference type.