Quick and Concise sorting without all the extra code or bother of implementing custom sorting through interfaces, sound impossible? Here we will use a generic list full of a custom object type of our defining and we will sort it using Anonymous Methods and the generic Comparer class provided for us by the .Net framework.

Custom Class:

public class Book

{

public string ISBN { get; set; }

public string Title { get; set; }

public int Volume { get; set; }

}

On the Fly Sorting:

{

List library = new List();

//Add a bunch of books to the library collection here

//Sort the library alphabetically by Title

library.Sort( delegate (Book bookOne, Book bookTwo)

{

return Comparer.Default.Compare(bookOne.Title, bookTwo.Title);

});

//Sort the library by Volume number

library.Sort( delegate (Book bookOne, Book bookTwo)

{

return Comparer.Default.Compare(bookOne.Volume, bookTwo.Volume);

});

}

As standard practice in .Net you create separate Event Handlers to handle the events of all controls on a form. In my personal code I always attempt to keep action code out of the event handlers and isolate it in its own method, this helps to keep things clean and easily altered if events change (see example below).

Example Code
        protected void Page_Load(object sender, EventArgs e)
        {
            Button1.Click += Button1_Click;
        }

        protected void Button1_Click(object sender, EventArgs e)
        {
            LoadSomeData();
        }

        private void LoadSomeData()
        {
            //Do something here.
        }
Now in .Net 2.0 we are allowed to use what are called Anonymous Methods. Anonymous Methods are code blocks which can be passed as (delegate) parameters to methods accepting delegates. Anonymous Methods allow us to get ride of extra methods and the overhead they create and simply pass an Anonymous Method. Because of this new feature instead of creating a separate method as an event handler to handle the button’s click event we can simply pass the Anonymous Method as the parameter using the delegate key word. This removes that extra method and reduces our code (see example below).
Example Code:
        protected void Page_Load(object sender, EventArgs e)
        {
            Button1.Click += delegate(object sender1, EventArgs e1)
                                 {
                                     LoadSomeData();
                                 };
        }

        private void LoadSomeData()
        {
            //Do something here.
        }

This is of course an extremely simplified use of Anonymous Methods meant to be just an example of how they work, although simple it is still a valid use and may or may not help you in your code. In future posts I will attempt to show the use of Anonymous Methods in more complex scenarios but for now at least we understand what they are and how they can be used.
	

In .Net C# there are 3 ways to cast an object to a specific type. Implicit, Explicit and As. So what is the difference and why do I need to know?

Implicit Casting: this is where the system takes care of the casting for you with no extra code on your part. Implicit Casting happens when one type such as an Int is cast to a Double. Because an Integer is a whole number (having no decimal place) and a Double is a floating point number (having a decimal place) the conversion of lets say the Integer 5 to a double of 5.0 no information about the original Integer is lost (5 == 5.0). Because there is no loss of data the .Net system has no issue with making the conversion without warning you.

Code Example:
{
    int i = 5;
    double d = i;
}

Explicit Casting: in this case there is the possibility data may be lost in the conversion from one type to another and the system therefore will not take care of the cast itself, it requires you to make sure you know what you are doing and specifically tell it you are fine if data is lost in the conversion. Taking our previous example and just switching it around a Double 5.25 cast to a Integer of 5 causes a loss of data and thus a loss in precision because of this .Net requires you to verify its OK to dump the .25 from the Double.

Code Example:
{
    double d = 5.25;
    int i = (int)d;
}

Both of the above Casting options will return an exception if the casting is not possible for any reason at all, thus casting needs to take place within a Try-Catch block in order to handle these situations. If you don’t want to handle exceptions thrown by these 2 Casting options there is one more that is rarely used by developers, the AS keyword.

AS: the as keyword in .Net allows you to specify an Explicit Cast needs to happen but instead of an Exception being thrown if the cast is not possible a null value is simply returned. Now you only need to check if the value is null before continuing on with your code, if it is you then have the option to do some more processing to get the value you need. This limits the overhead and code that is needed to handle casting exceptions. Now there is a limitation to the use of the as operator, unfortunately it only performs reference conversions or boxing conversions.  It cannot perform conversions like user-defined conversions for these you will need to use Explicit Casting.

Code Example:
{
    double d = 5.25;
    int i = d as int;
}

Microsoft has added a wonderful new addition to the .Net framework, Extension Methods! Extension methods allow you to add custom methods to already existing types (class) without the need to derive a new type from them or modify them (some of which you can’t such as built in .Net System types i.e. String, Int, Double). How it all works is these newly defined methods attach themselves to the type which they are referncing and can be used as if they are one of the original methods created at its inception. I good example of the perfect implementation of Extension Methods is the new LINQ library which when referenced in your code adds tons of new, fancy methods to collection types which implement the IEnumerable interface (there may be more to it than I have written here, but I am trying to be brief).

In order to set up your own custom Extension Methods within your assembly you need to define a Static Class which will hold all of these methods. Depending on the number of these methods you have for each type you wish to extend you may want to have a seperate Static Class for each of those types containing only the methods for that type. Extension Methods are Static just as the class that holds them.

Here is an example using the default System.String type:

public static class CustomStringExtensions

{
    public static bool ContainsQuestion(this String str)
    {
        return str.Contains('?');
    }
}

Now as long as you reference the assembly which contains this class every String object you use will automatically have the ContainsQuestion method.