Lets look at what MSDN has to say. As per the msdn

using block Defines a scope, outside of which an object or objects will be disposed.

The using statement allows the programmer to specify when objects that use resources should release them. The object provided to the using statement must implement the IDisposable interface. This interface provides the Dispose method, which should release the object’s resources.

Surprisingly even MSDN does not clarify how does this happen under the hood. It only says the object has to implement IDisposable interface that provides Dispose method on the object implementing the interface.  So to dispose the object it will need to call the Dispose method on the object which will cleanup and release the resources used by the object.

This led me to write some code and analyze the generated IL where I found the answers. Have a look at this code. I’ve written a class Car and made it IDisposable so that I can club its’ lifetime with using block.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace BlogSamples
{
    public class Car : IDisposable
    {
        public Car(int id)
        {
            this.Id = id;
        }

        public int Id { get; set; }

        public void Run()
        {
            Console.WriteLine("Car {0} is running.", this.Id.ToString());
        }

        #region IDisposable Members

        public void Dispose()
        {
            Console.WriteLine("Releasing resources used by Car object : " + this.Id.ToString());
        }

        #endregion
    }
}

Here’s my client-code. A sample ConsoleApplication that uses the Car object within the using block.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace BlogSamples
{
    class Program
    {
        static void Main(string[] args)
        {
            using (Car myCar = new Car(1))
            {
                myCar.Run();
            }
        }
    }
}

The output was obvious. Immediately after the using block the Dispose method of the Car object is called. Note that there are no signs of Dispose() method being called explicitly, still the method is called. Lets look at the generated IL.

.method private hidebysig static void  Main(string[] args) cil managed
{
  .entrypoint
  // Code size       37 (0x25)
  .maxstack  2
  .locals init ([0] class BlogSamples.Car myCar,
           [1] bool CS$4$0000)
  IL_0000:  nop
  IL_0001:  ldc.i4.1
  IL_0002:  newobj     instance void BlogSamples.Car::.ctor(int32)
  IL_0007:  stloc.0
  .try
  {
    IL_0008:  nop
    IL_0009:  ldloc.0
    IL_000a:  callvirt   instance void BlogSamples.Car::Run()
    IL_000f:  nop
    IL_0010:  nop
    IL_0011:  leave.s    IL_0023
  }  // end .try
  finally
  {
    IL_0013:  ldloc.0
    IL_0014:  ldnull
    IL_0015:  ceq
    IL_0017:  stloc.1
    IL_0018:  ldloc.1
    IL_0019:  brtrue.s   IL_0022
    IL_001b:  ldloc.0
    IL_001c:  callvirt   instance void [mscorlib]System.IDisposable::Dispose()
    IL_0021:  nop
    IL_0022:  endfinally
  }  // end handler
  IL_0023:  nop
  IL_0024:  ret
} // end of method Program::Main

Do you spot that compiler has introduced try/finally block and replaced it with using block. But why did compiler do that ? Lets observe the code and attempt to write similar C# code for better understanding. After careful analysis and reverse-engineering the equivalent C# code would look something as following.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace BlogSamples
{
    class Program
    {
        static void Main(string[] args)
        {
            //Declare myCar object with FullName of the type as seen in IL.
            BlogSamples.Car myCar;

            //Instantiate the object by calling the constructor, matching the flow of IL.
            myCar = new Car(1);

            try
            {
                myCar.Run();
            }
            finally
            {
                if(myCar != null)
                    myCar.Dispose();
            }
        }
    }
}

Above code is very clear. All it does is replace the code within the using block into the try block and calls the Dispose() method of the object in the finally block. As we all know, the code written in finally block gets executed in any situation even in case of any handled or un-handled exception. And this is how the using block ensures that the objects used with the using block are disposed for sure.

In fact using block is just a syntactic sugar for this pattern of code.

Some of you might wonder, how does the generated IL of the new reverse-engineered code look like. The IL of the reverse-engineered looks like this.

.method private hidebysig static void  Main(string[] args) cil managed
{
  .entrypoint
  // Code size       31 (0x1f)
  .maxstack  2
  .locals init ([0] class BlogSamples.Car myCar)
  IL_0000:  nop
  IL_0001:  ldc.i4.1
  IL_0002:  newobj     instance void BlogSamples.Car::.ctor(int32)
  IL_0007:  stloc.0
  .try
  {
    IL_0008:  nop
    IL_0009:  ldloc.0
    IL_000a:  callvirt   instance void BlogSamples.Car::Run()
    IL_000f:  nop
    IL_0010:  nop
    IL_0011:  leave.s    IL_001d
  }  // end .try
  finally
  {
    IL_0013:  nop
    IL_0014:  ldloc.0
    IL_0015:  callvirt   instance void BlogSamples.Car::Dispose()
    IL_001a:  nop
    IL_001b:  nop
    IL_001c:  endfinally
  }  // end handler
  IL_001d:  nop
  IL_001e:  ret
} // end of method Program::Main

Needless to mention that the IL in both the cases is identical to each other which proves the point that the using block is nothing but a syntactic sugar.

You might ask what if the constructor throws an exception. In this case the control would not move forward and never enter the proceeding try block. The object myCar still remains null. However you can wrap the using block in a try/catch block as shown below and handle the situation gracefully.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace BlogSamples
{
    class Program
    {
        static void Main(string[] args)
        {
            try
            {
                using (Car myCar = new Car(1))
                {
                    myCar.Run();
                }
            }
            catch
            {
                //Handle the situation gracefully.
            }
        }
    }
}

But why C# designers did not wrap object construction within the try block.

The reason is simple. If you wrap both declaration and instantiation within the try block then the object would be out of scope for the proceeding finally block and the code will not compile at because, for finally block the object hardly exists. If you only wrap the construction in the try block and keep declaration before the try block, even in that case the it will not compile since it finds use of an unassigned variable which is not allowed in C#.

Decorator pattern achieves a single objective of dynamically adding responsibilities to any object.

Consider a case of a pizza shop. In the pizza shop they will sale a few pizza varieties and have toppings that customers can order additionally on top of a pizza. Customer can order a pizza and add as many as toppings on the pizza. The cost of the ordered pizza will have to be calculated with pizza and all additional toppings. Now imagine a situation wherein if the pizza shop has to provide prices for each combination of pizza and topping. Even if there are four basic pizzas and 8 different toppings, the application would go crazy maintaining all concrete combination of pizzas and toppings. It is impractical to keep all combination in the menu. You’ll do enough to lose the customer when you expect him to go through such a long menu and do humongous brain-job.

Here comes the decorator pattern.

As per the decorator pattern, you will implement toppings as decorators and pizzas will be decorated by those toppings’ decorators. Practically each customer would want toppings of his desire and final bill-amount will be composed of the base pizzas and additionally ordered toppings. Each topping decorator would know about the pizzas that it is decorating and it’s price.

Here’s a code-example of explanation above.

//All your pizzas will inherit from this BasePizza class to identify themselves as pizzas.
public abstract class BasePizza
{
    protected double myPrice;

    //This method will return the price of the pizza object.
    public virtual double GetPrice()
    {
        return this.myPrice;
    }
}

//All toppings will inherit from this ToppingsDecorator class to be able to be added to any pizza in the pizza-shop.
public abstract class ToppingsDecorator : BasePizza
{
    //Each topping will need to know to which pizza it is being added to.
    protected BasePizza pizza;
    public ToppingsDecorator(BasePizza pizzaToDecorate)
    {
        this.pizza = pizzaToDecorate;
    }

    //This method will return cumulative price of both pizza and the topping.
    public override double GetPrice()
    {
        return (this.pizza.GetPrice() + this.myPrice);
    }
}

class Program
{
    [STAThread]
    static void Main()
    {
        //Client-code

        //First - order your base pizza. We'll add toppings onto this pizza.
        Margherita pizza = new Margherita();
        Console.WriteLine("Plain Margherita: " + pizza.GetPrice().ToString());

        //Add extra cheese.
        ExtraCheeseTopping moreCheese = new ExtraCheeseTopping(pizza);

        //Add some more cheese and make it double extra cheese.
        ExtraCheeseTopping someMoreCheese = new ExtraCheeseTopping(moreCheese);
        Console.WriteLine("Plain Margherita with double extra cheese: " + someMoreCheese.GetPrice().ToString());

        //Like mushrroms ? Add that too.
        MushroomTopping moreMushroom = new MushroomTopping(someMoreCheese);
        Console.WriteLine("Plain Margherita with double extra cheese with mushroom: " + moreMushroom.GetPrice().ToString());

        //Throw in some Jalapeno and make it sour and spicy.
        JalapenoToping moreJalapeno = new JalapenoToping(moreMushroom);

        //Add here's your final pizza.
        Console.WriteLine("Plain Margherita with double extra cheese with mushroom with Jalapeno: " + moreJalapeno.GetPrice().ToString());

    }
}

public class Margherita : BasePizza
{
    public Margherita()
    {
        this.myPrice = 6.99;
    }
}

public class Gourmet : BasePizza
{
    public Gourmet()
    {
        this.myPrice = 7.49;
    }
}

public class ExtraCheeseTopping : ToppingsDecorator
{
    public ExtraCheeseTopping(BasePizza pizzaToDecorate)
        : base(pizzaToDecorate)
    {
        this.myPrice = 0.99;
    }
}

public class MushroomTopping : ToppingsDecorator
{
    public MushroomTopping(BasePizza pizzaToDecorate)
        : base(pizzaToDecorate)
    {
        this.myPrice = 1.49;
    }
}

public class JalapenoToping : ToppingsDecorator
{
    public JalapenoToping(BasePizza pizzaToDecorate)
        : base(pizzaToDecorate)
    {
        this.myPrice = 1.49;
    }
}

Note that, GetPrice() method of Topping object would return cumulative price of both pizza and the topping.

public sealed class MySealedClass
{
    public MySealedClass() { }
}

public class MyGeneric<T>
        where T : MySealedClass
{
    public MyGeneric() { }
}

Surprisingly, Above code gives following compile error.

‘MySealedClass’ is not a valid constraint. A type used as a constraint must be an interface, a non-sealed class or a type parameter.

That was strange. We never observed such behavior before. Code was absolutely correct and it seemed like language designers had intentionally put this constraint to not allow sealed classed as generic constraints. But what must be the reason behind this ? Finally we had our thoughts in place and found the fact why it is so.

To understand, why sealed classes are not allowed to be generic type constraints, let us assume that sealed classes are allowed to be type constraints to generics. With this assumption the code above is valid and compiles successfully. Now lets write some client-code that would use this generic.

//create and instantiate an object of type MyGeneric
MyGeneric<MySealedClass> objGeneric = new MyGeneric<MySealedClass>();

Fair enough, this looks ok.

Now lets check what other types we can pass to MyGeneric type-argument at runtime. By defination, it has to be MySealedClass itself or any type that inherits from MySealedClass.

But won’t MySealedClass be the only valid type-argument for MyGeneric since MySealedClass cannot be inherited further and there will be no class that inherits from MySealedClass ? Doesn’t this defeat the whole idea of putting MySealedClass in type constraint to MyGeneric, since there’ll be no other valid-type argument except MySealedClass itself ? If MySealedClass is going to be the only valid type for MyGeneric, then  there’s no point in  defining MyGeneric as generic at all. Can’t we simply code against the type MySealedClass ?

We could finally realize the reason why language designers of  C# didn’t allow sealed classes as generic type-argument. quite enlightening.

While doing this we also came to realize why static classes are also not allowed to be generic type-constraints, though it’s very much obvious that static classes can never ever be generic type constraints. We found our answer in the compiled IL, where the static classes are marked as both abstract and sealed. Abstract since they cannot be instantiated and sealed since they cannot be inherited, hence cannot be generic type-constraints. In general only those types can be generic type-constraints which can have inheritance hierarchy below them, this includes interfaces, any non-sealed abstract or concrete classes.

This is a very light-weight Session-driven shopping cart written in VBScript. You can download the Shopping Cart from here and plug-n-play in your classic ASP applications.

Shopping Cart Demo

Download Shopping Cart Example with Source (8KB)

Screen-Shots

Shopping-Cart

Shopping-Cart Statistics

The example code includes the basic operations of shopping cart to let you understand how to add/update/delete items in cart. The unique key to any item in cart is the product-code or item-code. If an item or product is being added to cart and if any item in cart with same product/item-code already exists then the quantity of the item in cart will be increased by 1.

You also have option for cart statistics which you can use on every page to display the current cart stats. You can modify the look and feel the way you want as per your page layout and structure.

Thanks.

Ruchit S.

Don’t use plastic bags anymore!

Ruchit S.

You always help the next generation by sharing and giving whatever they need with whatever you can deliver. I got an opportunity to deliver a session on .net fundamentals last week at a good company out here. They wanted me to take a session on .net fundamentals and basics. Definitely, I opted for that. Believe me though I’ve been working on that platform for a long while now, to comprehend the contents in a presentation and a session of two hours was quite a challenging task. After putting lot of efforts, I could some how managed to do that.

It started out well, and eventually I dragged it towards an endless discussion which everybody just enjoyed it. We discussed in detail on CTS, CLS and many more issues. I inspired them to ask questions be it silly or meaningful, but they must ask. I had to gain them the confidence for working on .net platform since some of them were just college pass-outs and freshers hence.

With that note, I’m publishing my presentation on this blog which I showcased in the event. Hope it might help some one out there!

Topics: Microsoft .Net Fundamentals and Basics

Download Office 2003 Format

Download Office 2007 Format (preferable)

Ruchit S.

A marriage of server-side and client-side frameworks.

For all ASP.NET developers, the great news is that the very reach js framework for building RIA is now bound into a set of ASP.NET web controls.  Coolite Toolkit is an Ext official suite of ASP.NET Web Controls based on the Ext JavaScript Framework. Coolite, Inc. collaborates with ExtJS, LLC. The suite of web controls are (being) built with a focus on bringing full Visual Studio Design-Time support to the Ext JavaScript Framework.

You can visit the ExtJs examples page here to experience the capabilities of ExtJs. As you read this, Coolite is at version 0.4 and ships with these controls.

 
Developers using Coolite Toolkit benefit from features including:

• Powerful integration of the Ext JavaScript Framework.
• Full Design-Time support in Microsoft Visual Studio 2005 & 2008 and Visual Web Developer 2005 & 2008.
• Drag-and-drop ease of use.
• Current support for Window, Panel and a many Form Controls including DatePicker, Calendar and HtmlEditor.
• New Controls being added weekly.
• Dual Licensed (LGPL 3.0 and Coolite Commercial License).
• Professional support options available shortly.

You can just refer the Assembly in your \bin folder of website and additionally stick the controls to appear on your toolbox. You can check out the ExtJs Coolite ASP.NET Server Controls examples here and say wow!

Check out some more stunning examples here..

here , here and here.

Happy Programming!

Ruchit S.

I will blog about this as a series of posts, with this being the Part I itself. In this post, I will have you installed your first working mobile web server and provide you with features and functions. Later parts will include the architecture, how it works, the application areas and will try to elaborate more useful information and details on the web-server. So, here we go..

Getting Started:

To start with it, you must register and you can do so by filling up the form at this location. You must choose a valid and available Sub-Domain name for making your cell-phone uniquely reachable on the internet. Like mine is ruchit.mymobilesite.net and you can hit to the web-server running on my cell-phone by typing this URL in any web-browser, anywhere in the world. So, please choose a good name as well. The web-server can host CGI applications on py60 (Python for S60), static HTML web-pages and it comes with pre-bundled application with basic services which you can access at your URL, which in my case is http://ruchit.mymobilesite.net , as I said earlier. Once you’ve reserved a unique location on the web for your Cell-Phone + Web-Server, you can download the web-server and install it on your cell-phone. You can download the server from here. You can use Nokia PC suite to install the server application. After installation, your application menu should display with the icon of the server like this..

Now, start the application by clicking on the icon and you should see the main application menu. Now, our objective is to let the server know is identity by binding it to the respective URL, in my case as you know it’d be http://ruchit.mymobilesite.net. When you run it for the first time, it will detect it as fresh installation and will prompt you to punch in the most basic details to let itself bind it to a unique Internet location. You can download the User Manual from the web-site in order to complete the installation and play around with it in more details. Once you’ve started the server successfully you should see this screen on your mobile.

And yes, Symbian S60 2nd and 3rd edition phones have multitasking capabilities, so you can let this server be running in background continue working as normal. Phone like N95 and higher E series phones, have floating point units, which makes it a breeze.

Features and Functions:

You/Anybody can access your Web-Server by typing the associated unique URL, you gained as part of your registration process. You can have administrator logging into your cell-phone or you can entertain guest users as well. They will have following features accessible.

Camera: The person logged in can access your camera. The person can take pictures by clicking a single button and he can watch it straight on the browser and he can save that picture on local desktop. He can’t have the video streaming as this way beyond the scope of possibilities, demanding good amount of resources. Yes, you can think of real good ideas to tap on this feature. Like, you can so immediate sharing or remote cam kind of solution.

Web Chat: You can chat with the cell-phone owner in real time with his approval. It supports some smileys too.

Messaging: You can send a single message to the cell-phone owner like a quick-drop message for owner’s information or for any other important stuff.

Calendar: You can access person’s calendar entries right in the browser. You can manipulate them if you’ve enough rights or you can add one. How about adding your birth-day in your friends mobile without his knowledge and check back his expressions, thinking when reminded, “Hey, I never did it!”

Phone Log: You can access owner’s Dialed Calls’ Logs, Received Calls’ Logs and Missed Calls’ Logs in real time.

Presence: You can view cell-phone’s status and availability information, on which the web-server is running. You can learn, if an active call is ongoing or what’s battery level of the server phone or even the data bearer of the web-server, either EDGE, 3G or WLAN.

Send SMS: You can send an SMS to any-other cell-phone number from the web. This will be charged into owner’s telco. account.

GuestBook: You can fill up the guest book of the owner, if you like.

Contacts: You can access owner’s phone book on the web and manipulate, If you’ve got enough rights. How about checking a number you need without bothering your friend by asking, “Hey, do you have this guy’s number?”.

Gallery: You will have access to owner’s pictures album both on phone memory and external memory facilities.

Well, there are more other exciting features like blogging, contact me and etc. You can check out and download the latest version at http://www.mymobilesite.net. Feel free to comment or write to me on my email ruchit@ruchitsurati.net. Please mark the subject as ‘Mobile Web Server‘. More information on Mobile Web Server will follow this post in later posts. Till then Cheers!

Get Ready for the next generation of connected applications. It’s not that shallow as it seems. There’s lot more to it.

- Ruchit S.

My Windows Live IM Gadget code.

   1: <iframe src="http://settings.messenger.live.com/Conversation/IMMe.aspx?invitee=24f226172ef6427d@apps.messenger.live.com&mkt=en-US&useTheme=true&foreColor=333333&backColor=DCF2E5&linkColor=333333&borderColor=8ED4AB&buttonForeColor=2C0034&buttonBackColor=CFE9D9&buttonBorderColor=8ED4AB&buttonDisabledColor=CFE9D9&headerForeColor=006629&headerBackColor=92D6AE&menuForeColor=006629&menuBackColor=FFFFFF&chatForeColor=333333&chatBackColor=F4FBF7&chatDisabledColor=F6F6F6&chatErrorColor=760502&chatLabelColor=6E6C6C" width="300" height="300" style="border: solid 1px black; width: 300px; height: 300px;" frameborder="0"></iframe>

My Windows Live IM Button Gadget code.

   1: <script type="text/javascript" src="http://settings.messenger.live.com/controls/1.0/PresenceButton.js"></script>
   1:  
   2: <div
   3:   id="Microsoft_Live_Messenger_PresenceButton_24f226172ef6427d"
   4:   msgr:width="100"
   5:   msgr:backColor="#92D6AE"
   6:   msgr:altBackColor="#FFFFFF"
   7:   msgr:foreColor="#424542"
   8:   msgr:conversationUrl="http://settings.messenger.live.com/Conversation/IMMe.aspx?invitee=24f226172ef6427d@apps.messenger.live.com&mkt=en-US&useTheme=true&foreColor=333333&backColor=DCF2E5&linkColor=333333&borderColor=8ED4AB&buttonForeColor=2C0034&buttonBackColor=CFE9D9&buttonBorderColor=8ED4AB&buttonDisabledColor=CFE9D9&headerForeColor=006629&headerBackColor=92D6AE&menuForeColor=006629&menuBackColor=FFFFFF&chatForeColor=333333&chatBackColor=F4FBF7&chatDisabledColor=F6F6F6&chatErrorColor=760502&chatLabelColor=6E6C6C"></div>
   9: <script type="text/javascript" src="http://messenger.services.live.com/users/24f226172ef6427d@apps.messenger.live.com/presence?mkt=en-US&cb=Microsoft_Live_Messenger_PresenceButton_onPresence">
</script>

 
Now, This is how you do it in your web-site or blog..

You can visit this link and get the snippet which you shall put in desired part of your web page. Apart from the IM Control, you’ve got options for putting IM button or IM status Icon. You can find my IM button in Left-bar area.

http://settings.messenger.live.com/Applications/CreateHtml.aspx

The next thing, is to authorize your messenger status to be displayed on web pages. This is as simple as it gets. You can do so on this link.

http://settings.messenger.live.com/Applications/WebSettings.aspx

That’s it, Now you can run/view this page in your web browser. Surprised!

Note that, You’ll end up having a dumb and non-working messenger gadget in your web page if you’ve not done the authorization.

This gadget has been built upon using Script# framework from Nikhil Kothari from Microsoft. You can visit the project page here. Script# is a C# based development platform which when compiled generates JavaScript code instead of IL. Sounds cool, right? Well, it’s more than that. You can visit the project page and get started with Script#.

Cheers!