Using System.Life.Code;

Task and ConcurrentQueue

2011-11-13T16:39:00.001-05:00

In this blog, I will create a sample to demo the usage of Task and ConcurrentQueue. Task allows us to represent an asynchronous operation. ConcurrentQueue is a FIFO data structure similar to Queue, however, it is thread-safe. Thread-safe means that we will not have undesirable results in case multiple threads operate over this data structure.

First, let's see the code sample:

public class QueueObject
    {
        public DateTime StartTime { get; set; }
        public DateTime EndTime { get; set; }
        public int Id { get; set; }
        public int ConsumingThreadId { get; set; }
        public int ProducingThreadId { get; set; }
        public int DecimalPlaces { get; set; }
        public string Answer { get; set; }
    }

    class Program
    {
        private static ConcurrentQueue<QueueObject> bc = new ConcurrentQueue<QueueObject>();

        static void Main(string[] args)
        {
            Console.WriteLine("Main Thread Id: " + Thread.CurrentThread.ManagedThreadId);
           
            var t1 = Task.Factory.StartNew(ProduceTasks);
            
            var t2 = Task.Factory.StartNew(ConsumeTasks);
            var t3 = Task.Factory.StartNew(ConsumeTasks);
            var t4 = Task.Factory.StartNew(ConsumeTasks);

            Task.WaitAll(t1, t2, t3, t4);

            Console.WriteLine("ALL DONE");
            Console.ReadLine();
        }

        public static void ProduceTasks()
        {
            for (int i = 1; i <= 10; i++)
            {
                Thread.Sleep(1000);
                var qo = new QueueObject
                             {
                                 StartTime = DateTime.Now,
                                 Id = i,
                                 DecimalPlaces = 25000,
                                 ProducingThreadId = Thread.CurrentThread.ManagedThreadId
                             };
                bc.Enqueue(qo);
                Console.WriteLine("Enqueued: " + qo.Id + "\t" + qo.ProducingThreadId + "\t" + qo.StartTime.ToLongTimeString() + "\t" + qo.DecimalPlaces);
            }
        }

        public static void ConsumeTasks ()
        {
            try
            {
                // Consume bc
                while (true)
                {
                    QueueObject qo;
                    if (bc.TryDequeue(out qo))
                    {
                        qo.ConsumingThreadId = Thread.CurrentThread.ManagedThreadId;
                        qo.Answer = CalculatePi.Run(qo.DecimalPlaces);
                        qo.EndTime = DateTime.Now;
                        Console.WriteLine("Dequeued: " + qo.Id + "\t" + qo.ConsumingThreadId + "\t" + qo.EndTime.ToLongTimeString() + "\t" + qo.DecimalPlaces);
                    }
                }
            }
            catch (InvalidOperationException)
            {
                // IOE means that Take() was called on a completed collection
                Console.WriteLine("That's All!");
            }
        }
    }

In the main method, we are creating 4 tasks. 1 for producing (adding items to the queue) and 3 others for consuming (removing items from the queue). The StartNew() argument for Task takes an Action delegate item. By calling the WaitAll() method we direct the main thread to wait until all the threads have completed. We can also call the RunSynchronously() method on a task to make it run in the main thread rather than in a new thread.

In the ProduceTasks() method, we just line up 10 items in the queue. The QueueObject is created just to keep track of what the Queue is doing, so that we can display the details later.

In the ConsumeTasks() method, we call the TryDequeue() method to remove items from the queue. I use the QueueObject's DecimalPlaces property to calculate the value of pi. This gives me a real time consuming operation compared to using Thread.Sleep. You can download the pi calculation code from this link: http://www.boyet.com/articles/picalculator.html

Once the value of pi is calculated, we print the results on the console. The results are displayed below:

As you can see, Main Thread id is 9, while the enque (Task1) happened on thread 10. The Deque operation happened (Task2, Task3, Task4) across 3 thread 11, 12 and 13. The 3rd column shows the end time and the 4th column shows the number of decimal places pi was calculated to.

Similar to this, we can implement ConcurrentStack with pop and push operations.

ASP.NET MVC Caching

2011-10-30T10:17:00.001-04:00

In this blog post, I will document the caching mechanism provided in ASP.NET MVC3. MVC allows us to cache results from the whole controller or just some selected actions. It also provides parameters which help in configuring caching according to our needs.
The attribute used to enable caching is OutputCache. It can be applied to controllers or actions. Within OutputCache attribute we can specify the following arguments -

Duration - in seconds to keep the cache.
Location - specifies where the content should be cached. Possible values -

Any - default
Client - stored on client browser. It should be used in case you have personalized content per user.
Downstream - any proxy servers or client browser.
Server - stored on web server. It should be used in case the content is not user dependent.
None - no caching
ServerAndClient - caching on both locations

Nostore - informs proxy servers and browsers to not store a permanent copy of cached content
VaryByParam - allows to cache based on different parameters. It can increase the size of you cache dramatically, so it should be carefully used. Possible values -

* - Create a different cache whenever any parameters change
none - never create different cached versions
parameters separated by commas - create a different cache whenever any parameters in this list change.

CacheProfile - takes a string name for a profile named in config. The advantage of this is that its easier to manage all the cache settings in one place. Also, they can be changed without the need to recompile the application.

MVC3 CacheProfile: In MVC3, CacheProfile doesn't work for child actions. In that scenario, we have to use the other arguments such as Duration.

HTML 5 - Web Sockets and Microdata

2011-09-15T20:55:00.003-04:00

In this blog, I will continue to look at the new features of HTML5. This time I will pay attention to web sockets and microdata. Read on to learn more.

Web Sockets

web sockets are a mechanism to provide full-duplex communication over a single TCP socket.
A socket is basically a unique combination of local socket address, remote socket address and protocol (TCP, UDP).
socket address is combination of IP address and port number
HTTP by default is half-duplex i.e. at any given point of time, the communication can be only in one direction.
In case of web socket, client sends request to connect. Once the connection is made, client and server can communicate without the need to connect for every request. This comes in very handy for chat programs.
The other advantage of web sockets is performance. Normal HTTP headers can be 100s of bytes long but socket header is just around 2 bytes of data.
To use sockets in HTML5 is pretty easy. Once you have a server which allows for sockets, we can write the code as shown below to start web socket communication.

// web socket
    $('#logWebSocket').append("<li>Connecting to web server...</li>");
    var server = new WebSocket('ws://localhost:8181/server');
    server.addEventListener("message", msgWebSockHandler, false);
    server.addEventListener("open", openWebSockHandler, false);
    server.addEventListener("close", closeWebSockHandler, false);
    server.addEventListener("error", errorWebSockHandler, false);

    function msgWebSockHandler(e) {
        $('#logWebSocket').append("<li>Server Says: " + e.data + "</li>");
    }

    function openWebSockHandler(e) {
        $('#logWebSocket').append("<li>Connected to web server</li>");
    }

    function closeWebSockHandler(e) {
        $('#logWebSocket').append("<li>Disconnected from web server</li>");
    }

    function errorWebSockHandler(e) {
        $('#logWebSocket').append("<li>Error: " + e + "</li>");
    }

    $('#inputSocket').change(function (e) {
        server.send(this.value);
    });

In this code, first, we get a new socket by doing a new on WebSocket and provide it the server address. After that, we register event handlers for message, open, close and error. As you can see in the code, I am just outputting whatever data was sent back by the server. In the last piece of code, I have an input text box on the page. Everytime, the text changes in the text box, jquery sends the text to the server.

To create the server, I used sample code from nugget.codeplex.com. This is a very basic developement server. For production environments, something more robust should be used. Here is the image of server -

The client looks something like this -

Microdata

Microdata is an HTML5 specification which helps machines to read and understand the data. It allows to put semantics within existing content on web pages.
Search engines, web crawlers, browsers look for this data to provide other better user experience such as search results, snippets etc.
A collection of commonly used microdata vocabularies is located at http://data-vocabulary.org. This includes Person, Product, Offer, Event etc.
Some of the keywords used when describing microdata are -

itemscope - defines a container. For ex, if you put itemscope in a div element, that means that the descendants of this div element are going to contain the information about it.
itemtype - defines the url to the vocabulary. It tells what kind of data is contained in this itemscope.
itemprop - indicates that it holds the value of specified item property.
itemid - to uniquely identify at the scope level

HTML5 - Web Storage and Offline Capabilities

2011-09-05T22:00:00.001-04:00

In this blog, I will try to understand the new concepts with HTML5, namely, web storage which allows storing data on client side easier and offline capabilities which allow web apps to function even if they are offline.
Web Storage
There are 2 types of storage capabilities that we can use

Local

stored forever (until we delete either through app or clear temp files)
similar to cookies
accessed through window.localStorage property
is a collection of key-value pairs
can be removed using window.localStorage.removeItem(key) function
Whole storage can be cleared by using the window.localStorage.clear() function
The amount of storage used can be tracked by using the window.localStorage.length property
The amount of storage space remaining can be tracked by using the window.localStorage.remainingSpace property
If the space is exceeded, an exception of type QUOTA_EXCEEDED_ERR is thrown

Session

similar to local but data is lost once the session is over i.e, user closes the browser or user session ends.
accessed through window.sessionStorage property
is a collection of key-value pairs
can be removed using window.sessionStorage.removeItem(key) function
Whole session can be cleared by using the window.sessionStorage.clear() function
The amount of storage used can be tracked by using the window.sessionStorage.length property
The amount of storage space remaining can be tracked by using the window.sessionStorage.remainingSpace property
If the space is exceeded, an exception of type QUOTA_EXCEEDED_ERR is thrown

The storage component of HTML5 also exposes an event whenever any storage functionality happens. This event can be tapped into by using the window.addEventListener("storage", function (e) { // do something }). The argument e provides access to which key fired the event, old value, new value etc.

// storage event
    window.addEventListener("storage", function (e) {
        alert("storage event fired. Key = " + e.key +
            "\nNew Value: " + e.newValue +
            "\nOld Value: " + e.oldValue +
            "\nURL: " + e.url +
            "\nStorage Area: " + e.storageArea);
    }, false);

    // local storage
    if (localStorage.PageCount)
        localStorage.PageCount = Number(localStorage.PageCount) + 1;
    else
        localStorage.PageCount = 1;
    $('#locStore').val(localStorage.PageCount);

    if (localStorage.SomeValue)
        $('#locStore1').val(localStorage.SomeValue);

    $('#btnSaveLocStore1').click(function () {
        localStorage.SomeValue = $('#locStore1').val();
    });

    $('#btnDelLocStore1').click(function () {
        localStorage.removeItem("SomeValue");
        $('#locStore1').val("");
    });

    // session storage
    if (sessionStorage.PageCount)
        sessionStorage.PageCount = Number(sessionStorage.PageCount) + 1;
    else
        sessionStorage.PageCount = 1;

    $('#sessStore').val(sessionStorage.PageCount);

Here, I am providing some jQuery code which explains how to use the storage capabilities of HTML5. The first part is listening to the storage event. Currently, this only works in IE9. Afterwards, I use the local storage to keep track of page counts on this machine and also a user-defined value. I also provide a delete button to delete the local storage data. After that, there is a similar example for session storage. But that data is lost once you close the browser. The local storage data persists even if you close the browser. Here, is an image of the HTML form.

Offline
HTML5 provides capabilities to control a web app even when the user is offline. HTML5 provides the developer some easy rules to work with so that they can create apps that work when the user is offline and then once the user comes online, it can do some work to make the data sync with the server. Following are some of the pointers to get an offline app working -

Any app that should work offline should have a manifest file defined. It is this file that HTML5 looks for to provide offline functionality.
The rules for manifest file are as below -

first line in this file must be CACHE MANIFEST
second line identifies the version. This line is used to identify whether the version of files has been changed or not.
second section starts with the word CACHE
here we provide the list of all files that we want to be cached.
It is these files that get downloaded and stored on the client side when any change in the version is detected
if any one of the file download fails, HTML5 treats as the whole operation has failed.
third section is NETWORK
here we provide an exclusion list. This is a list of files that should never be cached.
fourth section is FALLBACK
here you can define a map to tie up online and offline pages. For ex. if you want to show an ABC page when you are online and an ABC-fallback page when you are offline, you can do so by providing a mapping here similar to /ABC /ABC-fallback
we also need to make sure that the ContentType of manifest file is set to "text/cache-manifest" and ResponseEncoding is set to "utf-8"

the offline api can be accessed using window.applicationCache property

there are few browser events that we can tap into as well. These events are called at certain stages -

First time loading

Checking (window.applicationCache.onchecking)
Downloading (window.applicationCache.ondownloading)
Progress
Cached (window.applicationCache.oncached)

subsequent loads (manifest hasn't changed)

Checking
No Update (window.applicationCache.onnoupdate)

subsequent loads (manifest has changed)

same as first time loading

at any given time, we can have the following cache states

0 - uncached
1 - idle
2 - checking
3 - downloading
4 - updateready (window.applicationCache.onupdateready) - this happens when download has been successful and browser can be notified that the app is ready to be reloaded.
5 - obsolete (window.applicationCache.onobsolete)

If we want to provide a manual action to update the application, we just need to call location.reload()
To do an automatic update we just need to call location.reload() in onupdateready() to trigger the reload.

HTML 5 GeoLocation Example

2011-09-04T21:30:00.001-04:00

In this blog, I will try to create a simple sample which uses the new geo location feature of HTML5. Read on -
The HTML5 geo location feature is very simple to use. In a nutshell, you call a method which returns a position object. This position object contains the position information such as

lattitude
longitude
accuracy (in metres)
altitude
altitude accuracy (in metres)
heading - direction in which you are moving
speed - speed with which you are moving

The sample code below shows how this method is called and how the values are populated in simple text boxes.

    $('#btnGeoLoc').click(function () {
        navigator.geolocation.getCurrentPosition(function (position) {
            $('#lat').val(position.coords.latitude);
            $('#long').val(position.coords.longitude);
            $('#accu').val(position.coords.accuracy);
            $('#alt').val(position.coords.altitude);
            $('#hdng').val(position.coords.heading);
            $('#speed').val(position.coords.speed);

            $('#viewMap').attr("href", "http://maps.google.com/maps?q=" +
                    $('#lat').val() + ",+" + $('#long').val() +
                    "+(You+are+here!)&iwloc=A&hl=en");

        },
        function () {
            alert("Error occurred");
        });
    });

Here, I am showing the code where there is a button on whose click I use some jQuery events to populate the textboxes. In the end, I enable a "view map" anchor tag with a link to google maps by using the latitude and longitude that we just obtained.
The getCurrentPosition method takes 2 arguments. Both are functions. The first one will get if the call is successful and the second one will get called if there was an error. We can then go through the error code to see what kind of error occurred and take subsequent action.
In this example, we used the getCurrentPosition() method. This method is used to get the position once. If you want to continuously monitor your position, you can use the watchPosition() method.

JQuery Cheatsheet

2011-08-29T23:01:00.007-04:00

To be good at JQuery, it is very important to understand and know how to select the HTML DOM elements. In this blog, I just wanted to provide some examples (more on the lines of a cheat sheet) of JQuery selectors which I use most often. I also wanted to document some of the methods that I use most of the times. I didn't want to go through JQuery documentation all the time. As I said, this list is not comprehensive but these are the items I use the most.

Selectors

$ is same as jquery.
$('#id') selects the element with id = id
$('p') selects all <p> elements
$('p,a,span') selects all paragraphs, anchor and span tags
$('ancestor descendants') selects all the descendants of ancestor. For ex. $('table tr') selects all tr tags in the table element. Descendants are children, grandchildren etc of ancestor.
$('.classname') selects all elements which have class = classname
$('.classA,.classB') selects all elements which have either classA or classB
$('p.classA') selects only <p> tags which have class = classA
$('a[title]') selects all <a> tags which have a title attribute
$('a[title="somelink"]') selects all <a> tags which have title attribute = somelink
$(':input') selects all input elements including input, textarea, select, button, image, radio, checkboxes etc. $('input') will select only <input> elements. Textarea is also input element but its written like <TextArea> that's why :input is handy.
$('div:contains("internet")') selects all the div elements whose value contains the text "internet"
$('tr:odd') and $('tr:even') selects all the odd and even rows respectively.
$('tr:first-child') and $('tr:last-child') selects the first and the last row respectively
$(input[value^="internet"]) selects all inputs whose value attribute STARTS with the word "internet"
$(input[value$="internet"]) selects all inputs whose value attribute ENDS with the word "internet"
$(input[value*="internet"]) selects all inputs whose value attribute CONTAINS the word "internet"
$('input', $('#mainDivs')) will find all inputs inside the mainDivs element
$('div:eq(0)', $('#mainDivs')) will find the first div inside the mainDivs element

Methods

.each(function(index, Element)) - loops through each element. It also provides the index of the item being looped. The current item can be referenced by using $(this) or using $(Element) where Element is the input passed. Usually we dont need to use $(Element) as $(this) does the job. So mostly the usage of each is like .each(function(index)).
.html() - gets the html.
.html(htmlString) - sets the html of the referenced element by htmlString.
.attr("id") - gets the value of the attribute id.
.attr("id","5") - sets the value of attribute id to 5.
.attr({"title":"some title", "alt":"5"}) - sets multiple attributes using JSON object. Text inside {} is a JSON object.
$('.phone').append("<br/>Ph: 123-456-7890") will APPEND the phone number to all elements which have class phone.
$('.phone').prepend("Ph: 123-456-7890<br/>") will PREPEND the phone number to all elements which have class phone.
$('.phone').wrap("<div></div>") will WRAP the div around all elements which have class phone.
$('.phone').unwrap() will UNWRAP the parent around all elements which have class phone.
$('.classA').css("border", "2px red solid") will apply border style with value 2px red and solid on all elements which have class = classA
$('.classA').css({"border":"2px red solid","font-size":"16px"}) will apply multiple styles (border and font-size) to elements with classA using JSON object
val() - gets the value of the element
val(str) - sets the value of the element to str
$('#t1').addClass("classexample") - adds the class classexample to element id #t1
$('#t1').removeClass("classexample") - removes the class classexample from element id #t1
$('#t1').toggleClass("highlight") - toggles the class i.e if class is applied, it removes it, if its not there, it adds it
$('#id').clone() - clones the id element

Events

$('#id').click(function(){ // do something }) will register a click event to element with id = id
$('#id').change(function(){ // do something }) change is mostly used for <select> elements. It gets fired everytime selection is changed. Inside the function $(this) will give you the changed value. change also works with textarea and input also.
$('#id').mouseenter(function(){ // do something}) is for mouseenter
$('#id').mouseleave(function(){ // do something}) is for mouseleave
$('#id').bind("mousenter", mouseEnterFunc) - binds the mouseenter event to item with id = id.
$('#id').bind("mouseenter mouseleave mouseup", bindingExample) - bind's main advantage is that it allows you to bind multiple events in a simple manner. Then in the bindingExample method, you can use e.type to see which event is called in case you want to do different things.
$('#id').bind({mouseenter:funcenter, mouseleave:funcleave, mouseup:funcup}) - will do the same thing as above but in JSON object
$('#id').unbind() - unbinds all the events associated with id
$('#id').unbind("mouseenter") - unbinds only the event specified
$('#id').delegate('input','keypress' function() { // do something }) - bind and delegate are similar. the only difference is that when you attach events through bind, any elements added through code or after load, the event will not get attached to these new elements. If you use delegate, it will keep on monitoring and even if new elements are added, it will attach the event handler. In this example, for anything under the context of id, a keypress event is attached to all inputs. When keypress happens, function will get called. You can use the undelegate function to get rid of event handlers.
$('#id').hover(func1, func2) - func1 is mouseenter and func2 is mouseleave.
$('#id').hover(func1) - func1 will be used as mouseenter and mouseleave. Its a good place to use toggleClass method.
$('#id').toggle(func1, func2, callback) - when you click id, first func1 will get called, at 2nd click func2 will get called. In the end callback will be called. This is good place to add some class in func1 add a different class in func2 and then remove the classes in callback. 4th click will then again call func1.
$('#id').toggle() - hides or shows the element. You can also provide a boolean for show and hide or duration and callback for it to fade out etc.

AJAX Functions

$('#id').load() - loads HTML data from the server. It provides capabilities to get parts of html by providing selectors or if the page takes arguments, we can send the arguments as well using JSON object. It also provides a call back function after the load is completed.
$.get(url,data,callback,type) - fires a get request. data is data sent to the server. callback contains the data returned from server apart from other arguments such as textStatus and jqXHR which is jquery XML Http Request object. type is the type of data server will return (HTML, XML, JSON)
$.getJson(ur, data, callback) - similar to get with type = JSON.
$.post(url,data,callback,type) - fires a post request. rest is same as get.
$.ajax({//settings json object}) - the low level api. Load, Get, Post all of them ultimately fire ajax function. ajax function arguments can be provided in the form of a json object and it provides more control with what we want to do with ajax calls.

CSS Selectors

#id word following after # is the id of the element to which css can be applied

.class word following after . is the class of elements to which css can be applied

Other Notes

Document.Ready is called when the page is loaded. i.e HTML DOM is loaded. It may mean that all images have not been loaded yet but DOM is loaded.

keyword this represents the raw DOM object while $(this) represents the raw DOM object wrapped inside jquery. Therefore, $(this) has jquery methods available to it while this does not. this has access to raw properties though.

CDN benefits - faster, cached, 99.9% uptime. Good for internet apps. For Intranet better to have your own copy.

EF Code First Example

2011-07-16T03:24:00.000-04:00

Entity Framework (EF) recently started supporting code-first development. This means that we don't have to create our database first before we can write any code. It allows developers to create their models (business entities, data objects etc) and then it will automatically create the database after very little configuration. I wanted to see how EF handles relationships. So I created this sample to demonstrate how EF code first handles many-to-many relationship.
For my app, the scenario is very simple. We have Person and Address entities. A person can have many addresses and an Address can belong to many persons. So, its a many to many relationship. To get up and running with an app, all the code I needed to write was this.

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

namespace CodeFirst
{
    class Program
    {
        static void Main(string[] args)
        {
            var ctx = new CodeFirstContext();

            //add few persons
            ctx.Persons.Add(new Person { Name = "Lionel Messi" });
            ctx.Persons.Add(new Person { Name = "Rafael Nadal" });
            ctx.SaveChanges();

            // add few addresses
            ctx.Addresses.Add(new Address {City = "Barcelona"});
            ctx.SaveChanges();

            //get Messi
            var person = ctx.Persons.Where(p => p.Name.StartsWith("Lionel")).SingleOrDefault();
            var addr = ctx.Addresses.Where(a => a.City == "Barcelona").SingleOrDefault();
            person.Addresses = new List<Address>();
            person.Addresses.Add(addr);
            person.Addresses.Add(new Address{City = "Mallorca"});
            ctx.SaveChanges();

            // get Nadal
            person = ctx.Persons.Where(p => p.Name.StartsWith("Rafael")).SingleOrDefault();
            addr = ctx.Addresses.Where(a => a.City == "Mallorca").SingleOrDefault();
            person.Addresses = new List<Address>();
            person.Addresses.Add(addr);
            ctx.SaveChanges();
           
            //get all
            var persons = ctx.Persons.Include("Addresses");

            foreach(var p in persons)
            {
                Console.WriteLine("\n" + p.Id + "   " + p.Name);
                foreach(var a in p.Addresses)
                    Console.WriteLine("\t" + a.Id + "    " + a.City);
            }

            Console.Read();
        }
    }

    public class Person
    {
        public int Id { get; set; }
        public string Name { get; set; }

        public List<Address> Addresses { get; set; }
    }

    public class Address
    {
        public int Id { get; set; }
        public string City { get; set; }

        public List<Person> Persons { get; set; }
    }

    public class CodeFirstContext : DbContext
    {
        public DbSet<Person> Persons { get; set; }
        public DbSet<Address> Addresses { get; set; }
    }
}

I also needed to make a small entry for connection string in the app.config as shown below.

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
  <connectionStrings>
    <add name="CodeFirstContext" 
         connectionString="Data Source=|DataDirectory|CodeFirst.sdf"
         providerName="System.Data.SqlServerCe.4.0"/>
  </connectionStrings>
</configuration>

In the database, you can see that EF created Persons, Addresses and AddressPersons table (junction table) to achieve many-to-many relationship.

If you see the code, all the code in main function is just trying to do CRUD operations to the DB. But to get the DB up and running we needed to write very little code. Also, for this code to work you will have to get the latest EF Code First package using Nuget. The output of this program is shown below -

.NET Reactive Extensions Rx - 3 (Cleanup)

2011-05-27T20:26:00.001-04:00

In this blog, I will create a small app to describe how to perform cleanup after the Rx subscription has finished its work.
Let's take a look at the code first -

    public class A03CleanupEx
    {
        internal static void Run()
        {
            Console.WriteLine("Thread: {0}\tMain application thread", Thread.CurrentThread.ManagedThreadId);
            var oSeq = Observable.Using<char, MyStreamReader>(
                () => new MyStreamReader(new FileStream("chars.txt", FileMode.Open)),
                sr => sr.ReadToEnd().ToCharArray().Select(c=>c).ToObservable(Scheduler.NewThread).Finally(FinalStep)
                );

            oSeq.Subscribe(Print);
        }

        private static void FinalStep()
        {
            Console.WriteLine("Thread: {0}\tFinally getting executed", Thread.CurrentThread.ManagedThreadId);
        }

        private static void Print(char c)
        {
            Console.WriteLine("Thread: {0}\t{1}", Thread.CurrentThread.ManagedThreadId,c);
        }
    }

    internal class MyStreamReader : StreamReader
    {
        public MyStreamReader(Stream fs) :base(fs)
        {
            Console.WriteLine("Thread: {0}\tStream Initialized", Thread.CurrentThread.ManagedThreadId);
        }

        protected override void Dispose(bool disposing)
        {
            Console.WriteLine("Thread: {0}\tStream Disposed", Thread.CurrentThread.ManagedThreadId);
            base.Dispose(disposing);
        }
    }

and here are the results -

Rx provides 2 ways of performing cleanup - using and finally. It is a good practice to cleanup the resources you might have used once you are done so that the streams are closed, the threads are returned back to thread pool etc.

Using
Rx framework provides Observable.Using to achieve this. We templatize the Using by providing first the type that will be the output once the subscription is run. In our case it is char. The second type is the type that you want to dispose once the operation is over. In our case it is MyStreamReader. I created MyStreamReader class just to tap into the constructor and the dispose method so that I can display some message on the console. Other than that, this class is the same as StreamReader. The Using method takes 2 arguments and both of them are delegates. The first delegate's output must be an object that you want to dispose. In our case, its type would be MyStreamReader. The second delegate than takes this object (sr) and should output an IObservable<T> where T in our case is char. The using method itself outputs an IObservable<T> where T in our case is char. This var can now be used to subscribe.

Finally
In my previous blog also, I touched a little bit about the Finally method. Finally method is similar in nature to our common try-catch-finally constructs in that the code in Finally will always get executed, irrespective of whether the operation is successful or an error occurred. As you can see in the results, after the subscription was over, Finally was called and once Finally was finished, Dispose was called to dispose the MyStreamReader object.

.NET Reactive Extensions Rx - 2 (Concurrency)

2011-05-25T01:08:00.013-04:00

In this blog, I will further explore Rx framework and specifically look into the concurrency and threading enhancements because I think this is where most of the value for Rx is.

Rx provides a very fine-grained control to the developers to choose on what kind of threads they want to run their subscriptions and observations. We can say that subscriptions are basically the calls to get the next item in the observable collection and observations are what we do with that item once we have got it. So, if we are iterating through a collection of numbers, subscription means getting that number (through the query) and observation means doing the OnNext, OnError and OnCompleted operations on that number. Keep in mind that even if we use different threads, Rx guarantees that the order is maintained. That is, if the observable collection contains 1,2,3 and you do some Rx operations on this, it will be processed in the same order. Meaning that, operation on 2 wont be called until 1 is completed and so on and so forth. The only caveat to this is that Rx only guarantees the order of observations and doesn't guarantee the order for subscriptions.To demonstrate threading scenarios, I have created a simple WPF app with a bunch of buttons that display some text in the underlying textbox. Since, there are cases in which I wanted to do the observation operations in different thread, it was not possible for me to append the text to textbox (as textbox is in the main thread). In that case I output my text to Debug->Output window by using the PrintToDebug() method. Let's take a look at the code and its results -

public partial class MainWindow : Window
    {
        public MainWindow()
        {
            InitializeComponent();
            Example8Stop.IsEnabled = false;
        }

        private string PrintThreadId()
        {
            return "Thread:" + Thread.CurrentThread.ManagedThreadId;
        }

        private void CleanTB()
        {
            tb.Text = "Main " + PrintThreadId() + "\n";
        }

        private void Print(string str)
        {
            tb.AppendText(str + "\nObservation\tPrint\t\t" + PrintThreadId() +"\n");
        }

        private void PrintToDebug(string str)
        {
            Debug.WriteLine(str + "\nObservation\t\tPrint\t\t" + PrintThreadId() + "\n");
        }

        private void EndMethod()
        {
            tb.AppendText("\nEndMethod\t" + PrintThreadId() + "\tTask is complete\n");
        }

        private void ErrorMethod(Exception ex)
        {
            tb.AppendText("\nErrorMethod" + PrintThreadId() + "\t" + ex.Message + "\n");
        }

        private void Example1_Click(object sender, RoutedEventArgs e)
        {
            CleanTB();
            tb.AppendText("\nDemonstrating Scheduler.NewThread. See output in the debug-output window.");
            var numbers = new List<int> { 1, 2, 3 };
            var query = numbers.Select(n => SlowDown(n));

            var oQuery = query.ToObservable(Scheduler.NewThread);
            oQuery.Subscribe(PrintToDebug);
        }
       
        private void Example2_Click(object sender, RoutedEventArgs e)
        {
            CleanTB();
            tb.AppendText("\nDemonstrating SubscribeOn On NewThread.");

            var numbers = new List<int> { 1, 2, 3 };
            var query = numbers.Select(n => SlowDown(n));

            var oQuery = query.ToObservable();
            oQuery.SubscribeOn(Scheduler.NewThread).Subscribe(PrintToDebug); 
        }

        private void Example3_Click(object sender, RoutedEventArgs e)
        {
            CleanTB();
            tb.AppendText("\nDemonstrating ObserveOn on NewThread.");

            var numbers = new List<int> { 1, 2, 3 };
            var query = numbers.Select(n => SlowDown(n));

            var oQuery = query.ToObservable();
            oQuery.ObserveOn(Scheduler.NewThread).Subscribe(PrintToDebug);
        }

        private void Example4_Click(object sender, RoutedEventArgs e)
        {
            CleanTB();
            tb.AppendText("\nDemonstrating SubscribeOn and ObserveOn on NewThread.");

            var numbers = new List<int> { 1, 2, 3 };
            var query = numbers.Select(n => SlowDown(n));

            var oQuery = query.ToObservable();
            oQuery.SubscribeOn(Scheduler.NewThread).ObserveOn(Scheduler.NewThread).Subscribe(PrintToDebug);
        }

        private void Example5_Click(object sender, RoutedEventArgs e)
        {
            CleanTB();
            tb.AppendText("\nDemonstrating SubscribeOn and ObserveOn on ThreadPool.");

            var numbers = new List<int> { 1, 2, 3 };
            var query = numbers.Select(n => SlowDown(n));

            var oQuery = query.ToObservable();
            oQuery.SubscribeOn(Scheduler.ThreadPool).ObserveOn(Scheduler.ThreadPool).Subscribe(PrintToDebug);
        }

        private void Example6_Click(object sender, RoutedEventArgs e)
        {
            CleanTB();
            tb.AppendText("\nDemonstrating SubscribeOn NewThread and ObserveOnDispatcher.");

            var numbers = new List<int> { 1, 2, 3 };
            var query = numbers.Select(n => SlowDown(n));

            var oQuery = query.ToObservable();
            oQuery.SubscribeOn(Scheduler.NewThread).ObserveOnDispatcher().Subscribe(Print);
        }

        private void Example7_Click(object sender, RoutedEventArgs e)
        {
            CleanTB();
            tb.AppendText("\nDemonstrating SubscribeOnDispatcher and ObserverOn NewThread.");

            var numbers = new List<int> { 1, 2, 3 };
            var query = numbers.Select(n => SlowDown(n));

            var oQuery = query.ToObservable();
            oQuery.SubscribeOnDispatcher().ObserveOn(Scheduler.NewThread).Subscribe(PrintToDebug);
        }
        
        private void Example8_Click(object sender, RoutedEventArgs e)
        {
            Example8.IsEnabled = false;
            Example8Stop.IsEnabled = true;
            CleanTB();
            tb.AppendText("\nDemonstrating Finally and disposing the subscription");

            var numbers = Enumerable.Range(1, 100);
            var query = numbers.Select(n => SlowDown(n));

            var oQuery = query.ToObservable()
                .SubscribeOn(Scheduler.NewThread)
                .ObserveOnDispatcher()
                .Finally(FinalAction);
            m_sub = oQuery.Subscribe(Print);
        }

        private void Example8Stop_Click(object sender, RoutedEventArgs e)
        {
            m_sub.Dispose();
        }

        private void FinalAction()
        {
            tb.AppendText("\nFinal Action\t" + PrintThreadId());
            Example8.IsEnabled = true;
            Example8Stop.IsEnabled = false;
        }

        private string SlowDown(int n)
        {
            Thread.Sleep(500);
            return "\nSubscription\tSlowDown\t" + PrintThreadId() + "\t\tValue:" + n;
        }

        private IDisposable m_sub;
    }

As you can see in this code SlowDown() method is part of subscription as it is part of the query that iterates to get the next item while Print() and PrintToDebug() methods are part of observations as they are the OnNext delegates.Example1

In Example1, when we provide the Scheduler.NewThread argument to the ToObservable() method, it means that all the subscriptions (getting next items) should be performed on a new thread. So as you can see in the application that main thread id is 8 but subscriptions ran on thread 10. Since we didnot provide any such parameter for observations, they also ran on thread 10. Example2

Example2 does the same thing as Example1. The only difference is that instead of providing Scheduler.NewThread argument to the ToObservable() method, we are using the SubscribeOn(Scheduler.NewThread) to achieve the same result.Example3

In Example3, we utilize the ObserveOn() method. This tells the Rx framework that all observations (in our case the print methods) should run on a new thread. As you can see, the main thread is 10 and all subscriptions ran on thread 10 (since we didn't provide anything for subscriptions) while all observations ran on different new threads. Scheduler.NewThread for subscriptions means that run the subscription on any other thread other than the main thread. While, Scheduler.NewThread for observations means that run the observations on a completely new thread.Example4

In Example4, we use both the SubscribeOn and ObserveOn methods. And as i said before that for subscriptions NewThread just means a different thread from the main thread while for observations, it means a completely NewThread, we can see the same in the results. All subscriptions ran on thread 13 which is different from thread 10 (main thread) while all the observations ran on a completely different new thread.Example5

Example5 is similar to Example4 and the only difference is that instead of NewThread we are using ThreadPool. This means that instead of creating new threads, available and free threads from the pool will be used. The other difference between them is that NewThread creates the thread in foreground while ThreadPool threads are in the background. Foreground threads will make the main app wait until all their tasks are done while background threads will not execute if the main thread has finished its work. Since this time we used the ThreadPool, all observations ran on thread 11 which was available and free. If you run this code for large numbers you will see different threads being used again and again as and when they became free.Example6

In example6, we are using subscribe on new thread but ObserveOnDispatcher(). This means that all observations should run on the dispatcher thread which is the main thread. It is for this reason, that we are able to print the results in this window rather than in the debug window. As you can see in the results, due to NewThread on subscriptions, they ran on a different thread (7) than main thread (9) while all the observations ran on the main thread (9).Example7

In example7, we use the SubscribeOnDispatcher() while run the observations on a new thread. The results show that all subscriptions ran on the same thread (9) as the main thread while all observations ran on the new thread.Example8

Finally, example 8 adds a few more important points the the example to make it complete. First thing to notice is that we have added a corresponding Ex 8 Stop button for Ex 8 button. This stop button allows us to stop the execution midway. To do this, first we declare a local IDisposable variable to keep its value outside the scope of the function. Then, when Ex 8 Stop is clicked, we just call the Dispose() on this variable, as shown in the click handler of Ex 8 Stop. The other thing to note here is that to perform some kind of cleanup, we have added a Finally method. This Finally method is called even if the execution is stopped or an error occurs or the execution completes successfully. For this reason, we couldn't use the OnCompleted to perform cleanup because OnCompleted will not get called if the execution is stopped mid-way or if an error occurs.

There are few other helpful methods, which I won't go in detail, but they are useful. We can use Buffer and Window methods in cases where we need to work with multiple items rather than single item. So for ex, we can specify in the buffer method a count of 10. Then, in the subscription, instead of getting one item, we will get a list of 10 items. Both these methods also allow us to provide a timespan instead of a count. If we provide timespan than the buffer will contain as many items as it was able to fetch in that timespan. Buffer and Window work similarly and they only differ in their return type.

.NET Reactive Extensions Rx - 1 (Basics)

2011-05-23T01:59:00.004-04:00

In this blog, I will explore the reactive extensions (Rx) framework. Rx extends .NET. Rx extends LINQ so that results of a query can be converted to an observable sequence. Let's explore more..
You can download Rx from the MSDN website. Once the msi is run, you can add references to System.Reactive dll to get started. Since Rx is heavily based on Observer pattern - let's take a look at what this pattern is -
Observer Pattern
I always find it easy to understand a pattern with an example and the example of bulb-switch is used commonly to describe the Observer pattern. In a bulb-switch example, the bulb is an observer as it is observing the switch. Whenever the state of switch changes, bulb has to do something. The switch in this case is called a subject. Rx defines 2 interfaces that describe the behavior of observer and switch. For observer, Rx has IObserver interface which defines OnNext(), OnCompleted() and OnError(Exception ex) methods. For subject, Rx has IObservable interface which has one method called Subscribe(IObserver) which takes as input an IObserver.
Let's take a look at some very simple code that uses Rx framework:

class Program
    {
        static void Main(string[] args)
        {
            var numbers = new List<int> {1, 2, 0, 3, 4, 5, 6, 7, 8, 9, 10};
            var query = numbers.Take(5);
            
            // simple way
            foreach(var digit in query)
              Print(digit);
            EndMethod();

            // oQuery is the subject (switch) and Print is the observer (bulb)
            var oQuery = query.ToObservable();
            oQuery.Subscribe(Print);
            Console.WriteLine();

            // demonstrating an OnComplete scenario
            oQuery = query.ToObservable();
            oQuery.Subscribe(Print, EndMethod);

            // demonstrating an error scenario
            oQuery = query.ToObservable().Select(n => 10 / n);
            oQuery.Subscribe(Print, ErrorMethod, EndMethod);
            
            Console.Read();
        }

        static void Print(int i)
        {
            Console.WriteLine(i);
        }

        static void EndMethod()
        {
            Console.WriteLine("Task is complete");
            Console.WriteLine();
        }
        
        static void ErrorMethod(Exception ex)
        {
            Console.WriteLine(ex.Message);
            Console.WriteLine();
        }
    }

and when I run this app, these are the results that I get -

The foreach loop demonstrates a typical way in which we are used to do the things. We loop through each number and then we do something with that number and in the end get out of that code block.
In the next code piece, we start to use the Rx framework. As mentioned earlier, we need an IObserver and an IObservable to work with. We convert the query to IObservable by calling the ToObservable method. This method converts IEnumerables to IObservables. Once the query is converted to an IObservable, we call the Subscribe() method on it. In the Subscribe() method we have to provide an IObserver. We don't really need to provide an IObserver but instead we can provide the 3 methods that IObserver implements, i.e, OnNext(), OnCompleted() and OnError(). In my code, I have 3 code pieces using different overloads. In the first one, I just pass a delegate for OnNext. In the second one, I pass OnNext() and OnCompleted() and in the third one, I pass all the 3. The rule to remember here is that OnNext() will be called one or more times depending on the number of items. OnError will get called if there is an error. If OnError is called, OnCompleted() won't be called and if OnCompleted() is called that means OnError() was not called and the operation was successful. OnNext() will never get called after either OnError() or OnCompleted() is called.
You might wonder as to what is the big deal about this Rx framework since all that we did above can be easily done using the foreach loop and try-catches. The real power of Rx comes into play when we start to utilize it in asynchronous scenarios, which will be the topic of my next blog.

HTML 5 Basic Examples

2011-05-22T01:13:00.007-04:00

In this blog, I will try to understand what is HTML5 and what enhancements it brings over current HTML. I will also try to write some sample code to demonstrate the new features.
In very simple terms, HTML5 is a combination of existing markup, new markup additions and JavaScript APIs. The JavaScript APIs form the bulk of what is new in HTML5. One of the reasons why HTML5 is gaining so much attention is because it has inherent support for rich media such as audio and video. So, we don't have to install other plugins to achieve this result.

I will just publish here the code for some sample tags, new markups that I wrote and in the end there is an image of the webpage running in chrome. One good thing about HTML5 is that it is very simple to learn almost to the extent of being self-explanatory.

Keep in mind that some of the stuff might not work on your machine depending upon the browser you are using. Also, as you can see, I am using scripts from http://www.modernizr.com/ to detect HTML5 capabilities on my browser.


<!DOCTYPE HTML>
<html>
<head>
    <title>HTML5 Examples</title>
    <script src="Scripts/modernizr-1.7.min.js" type="text/javascript"></script>
    <script type="text/javascript">
        function init() {
            var c = document.getElementById("myCanvas");
            var cxt = c.getContext("2d");
            cxt.fillStyle = "#FF0000";
            cxt.beginPath();
            cxt.arc(70, 18, 15, 0, Math.PI * 2, true);
            cxt.closePath();
            cxt.fill();
        }

        if (localStorage.pagecount) {
            localStorage.pagecount = Number(localStorage.pagecount) + 1;
        }
        else {
            localStorage.pagecount = 1;
        }
        document.writeln("<h2>Local Storage Example</h2>");
        document.writeln("<h4>Stored forever</h4>");
        document.writeln("Visits: " + localStorage.pagecount + " time(s).");
        document.writeln("<hr color=orange />");

        if (sessionStorage.pagecount) {
            sessionStorage.pagecount = Number(sessionStorage.pagecount) + 1;
        }
        else {
            sessionStorage.pagecount = 1;
        }
        document.writeln("<h2>Session Storage Example</h2>");
        document.writeln("<h4>Stored for the session - as long as the browser is open</h4>");
        document.writeln("Visits: " + sessionStorage.pagecount + " time(s).");
        document.writeln("<hr color=orange />");

        document.writeln("<h2>Modernizr Example</h2>");
        document.writeln("Audio capability: " + Modernizr.audio + "<br/>");
        document.writeln("Video capability: " + Modernizr.video + "<br/>");
        document.writeln("Web SQL DB capability: " + Modernizr.websqldatabase + "<br/>");
        document.writeln("<hr color=orange />");
    </script>
</head>
<body onload="init()">
    <div>
        <header>
            <a href="http://www.google.com">
            <hgroup>
            <h2>Header Example</h2>
            <h3>grouped insided hgroup which is wrapped inside an a element to provide hyperlink</h3>
            </hgroup>
            </a>
            <hr color="orange" />
        </header>

        <nav>
        <h2>Nav Example</h2>
        <ul>
            <li><a href="http://www.google.com">Google</a></li>
            <li><a href="http://www.cnn.com">CNN</a></li>
            <li><a href="http://www.cnn.com">CNN</a></li>
        </ul>
        <hr color="orange" />
        </nav>
        
        <section>
        <h2>Canvas Example</h2>
        <canvas id="myCanvas" width="200" height="100" style="border: 1px">Your browser does not support canvas.</canvas>
        <hr color="orange" />
        </section>
        
        <section>
        <h2>Video Example</h2>
        <video src="Videos\movie.ogg" width="320" height="240" controls="controls">Your browser does not support the video tag.</video>
        <hr color="orange" />
        </section>

        <section>
        <h2>Audio Example</h2>
        <audio src="Audios\HudHud.mp3" controls="controls">Your browser does not support the video tag.</audio>
        <hr color="orange" />
        </section>

        <section>
        <aside style="font-size:larger;font-style:italic;color:red;float:right;width:300px;border:2px solid black">
            Aside example: This text is on the side because it is inside the aside tag. 
        </aside>
        <h2>Mark Example</h2>
        <mark>This text is highlighted because it is inside the mark tag.</mark>
        <hr color="orange" />
        </section>

        <details>
            <h2>Details - Summary Example (Currently not implemented in chrome)</h2>
            <summary>This is summary</summary>
            <div>Lots of details here: Lots of details here: Lots of details here: Lots of details here: Lots of details here: Lots of details here: Lots of details here: Lots of details here: Lots of details here: 
            Lots of details here: Lots of details here: Lots of details here: Lots of details here: Lots of details here: Lots of details here: Lots of details here: Lots of details here: Lots of details here: 
            Lots of details here: Lots of details here: Lots of details here: Lots of details here: Lots of details here: Lots of details here: Lots of details here: Lots of details here:  </div>
            <hr color="orange" />
        </details>

        <section>
        <h2>datalist Example</h2>
        <label>Who's greatest
        <input type="text" name="favCharacter" list="players">
          <datalist id="players">
           <option value="Sachin Tendulkar">
           <option value="Roger Federer">
           <option value="Diego Maradona">
          </datalist>
        </label>
        <hr color="orange" />
        </section>

        <section>
        <h2>Input types examples</h2>
        <input type="search" id="search" name="search" autofocus/><br/>
        <input type="url" id="urlinput" name="urlinput" placeholder="Choose URL" /><br/>
        <input type="tel" id="tel" name="telinput" placeholder="Choose telephone number" /><br/>
        <input type="color" id="color1" name="colorinput" placeholder="Choose color" /><br/>
        <input type="number" id="num1" name="numinput" placeholder="Choose number" /><br/>
        <input type="date" id="date1" name="dateinput" placeholder="Choose date" /><br/>
        <hr color="orange" />
        </section>
        
        <section>
        <h2>Time Example</h2>
        <time datetime="2011-05-26T16:48:43" pubdate>May 26, 2011</time>
        <hr color="orange" />
        </section>

        <footer>
        <h2>&copy Footer example</h2>
        <hr color="orange" />
        </footer>
    </div>
</body>
</html>

Android - 2 (Eclipse project)

2011-05-18T01:45:00.001-04:00

Now that I understand some of the basics of Android development, I will start exploring more into the Android and Eclipse project and get a better idea about what the files in this project mean. Then I will try to create a simple app to sort of gel all the ideas together. Lets get started -
Android Project - The android project consists of the following folders and files

src - contains your code packages (namespaces) and code files
gen - contains the files generated by Eclipse
res - contains the resources files
Android Manifest - contains the configuration settings for the project

Activity - An activity is a single focussed thing that a user can do. Since most of the activities interact with the user, Activity class creates a window in which we can place our UI components. The following diagram shows the life cycle of an activity. This diagram is taken from developer.android.com.

Sample Application - We will try to build a simple app in Android which will allow us to insert some text in a textbox and on click of a button will log the text in the debug logger. We will also create a help button, which will allow us to go to a different activity.

So, first up, I create a MainActivity and add a EditText and a button to the UI. Then in my MainActivity.java file in the onCreate of MainActivity, I write the following code -

Here, in the MainActivity class I create an OnClickListener variable that takes care of the click event. Here, unlike .NET, we can not get the text value by doing something like EditText.Text. There are no such properties, so we have to use the findViewById method to find the view and then use its getText() method to get the text. Log.d takes a tag and a message.

Now to create another view, we use the New-Class feature to create HelpActivity.java. In the onCreate for this Activity, we create a TextView on the fly and set some Text into that as shown below -

This creates the view, but we haven't hooked it up with the MainActivity yet. So, I create a Help button in the UI and add an OnClickListener to it in the MainActivity.java file. In the listener, we create a new Intent and then start the activity. An Intent is a way in android to suggest some kind of action or something that we want to do. In this case, we are telling Android to

We also need to hookup this HelpActivity in the Android Manifest file as well as shown below -

When you run the app, you see the following -

After clicking the button, you can navigate to the DDMS perspective in Eclipse and in the LogCat window, you can see the text logged as shown below.

After clicking the help button, you can see that the app navigates to a different view.

If you are wondering, why this app is called Calculator, thats because I plan to create a simple Calculator app but just for starters, I created this app.

Android - I

2011-05-17T01:26:00.003-04:00

In this blog, I will look into the overview of Android and how we can use .NET to build applications for Android. I will continue to explore more until I am ready to create an android app and publish it in the android market.
Android is an open source, linux based, mobile operating system. The application layer for Android is written in Java.
Android Architecture

Linux kernel - This forms the core. This core has lots of drivers that interact with the actual hardware of the device.
Libraries - On top of the core are the libraries mostly written in c and c++. One of the libraries is SQLLite which is the underlying DB used by Android. There is also an Android runtime that consists of its own libraries. Each app runs in its own VM.
Application Framework - On top of libraries lies the application framework. Most of our coding is done against this framework.
Applications - On top of the application framework lies the actual applications.

Application Life Cycle

Anything that we do in an android app can be termed as a task. For ex. sending an email.
A task is a set of activities.
These activities get arranged in a stack (LIFO)
All apps run in their own process. They also have their own Linux user id.
Android does the job of managing memory and killing least important ones. There is a chance that one of the applications that was in a stack, got killed because Android memory management kicked in. So we need to take care of this on our end to restore the killed task.

Coding for Android - To start coding for android, you need the following.

JDK - Java Development Kit. JDK is a development environment for building applications.
Eclipse - is an open source JAVA IDE backed by Google.
Android SDK starter package - contains core SDK tools
ADT - Android Development Tools

This was a very basic introduction to working with Android. In the next blog, I will go a bit deeper to creating and understanding the nuances of building Android applications.

Out for a while

2011-03-31T14:36:00.000-04:00

Last few days, I haven't posted any new blog. That is partly due to laziness and mostly due to Cricket world cup. Also, now I am leaving for India for a month, so there will be no blogs in April as well. I hope to be back to studying and writing from May.

C# Set Operations

2011-03-07T01:49:00.001-05:00

In this blog, I will cover 2 data structures, namely, HashSet and SortedSet and will create small examples to show how we can achieve mathematical set operations of Union, Intersect, Minus etc with these data structures.
HashSet<T>

It uses a hashing algorithm to lookup items in a set and therefore is fast. Due to this, it takes up a bit of additional space.
Dictionary<TKey,TValue> should be used if there is a key available. However, if no such key is available then using HashSet<T> is better. In that sense, HashSet<T> is kind of similar to Dictionary<T,T> that is, where the key and value are the same.
In general sense, HashSet takes a constant amount of time to do Add, Remove or Contains operations, irrespective of how large or small the size might be. A List<T>, as the size increases, will take more time to perform these operations.
It implements ISet<T>. ISet<T> is an interface that provides the methods to perform set operations such as UnionWith, IntersectWith, ExceptWith etc.
HashSet also provides extension methods such as Union, Intersect, Except. The difference between these and methods with "With" is that methods with "With" modify the calling HashSet and return void. Methods without "With" return a separate IEnumerable<T>.

SortedSet<T>

Is similar to HashSet<T> except that the items are kept in a sorted manner as and when they are added.
Most of the points mentioned above are true for SortedSet as well.
Similar to how Dictionary<TKey, TValue> has a SortedDictionary<TKey, TValue>.
Performs a bit slower than HashSet<T> as it spends some time in sorting.

Set Operations

Union: {1,2,3,4} union {3,4,5} = {1,2,3,4,5}
Intersect: {1,2,3,4} intersect {3,4,5} = {3,4}
Minus (Except): {1,2,3,4} minus {3,4,5} = {1,2}
Superset: {1,2,3,4} is superset of {3,4}
Subset: {3,4} is subset of {1,2,3,4}
ProperSuperSet:

{1,2,3,4} is proper superset of {1,2,3,4} - FALSE
{1,2,3,4} is superset of {1,2,3,4} - TRUE
{1,2,3,4} is proper superset of {2,3} - TRUE
{1,2,3,4} is superset of {2,3} - TRUE

ProperSubSet:

{1,2,3,4} is proper subset of {1,2,3,4} - FALSE
{1,2,3,4} is subset of {1,2,3,4} - TRUE
{2,3} is proper subset of {1,2,3,4} - TRUE
{2,3} is subset of {1,2,3,4} - TRUE

Let's take a look at the code listing below:

public static class A08DataStructures
    {
        public static void Run()
        {
            HashSetExample();
            SortedSetExample();

            // Set operations
            IntersectExample();
            UnionExample();
            ExceptExample();
            SupersetSubsetExample();
        }

        private static void IntersectExample()
        {
            Console.WriteLine("\nIntersect Example");
            var hs1 = new HashSet<int>() { 1, 2, 3, 4 };
            var hs2 = new HashSet<int>() { 3, 4, 5 };
            hs1.IntersectWith(hs2);

            foreach (var i in hs1)
                Console.WriteLine(i.ToString());
        }

        private static void UnionExample()
        {
            Console.WriteLine("\nUnion Example");
            var hs1 = new HashSet<int>() { 1, 2, 3, 4 };
            var hs2 = new HashSet<int>() { 3, 4, 5 };
            hs1.UnionWith(hs2);

            foreach (var i in hs1)
                Console.WriteLine(i.ToString());
        }

        private static void ExceptExample()
        {
            Console.WriteLine("\nExcept Example");
            var hs1 = new HashSet<int>() { 1, 2, 3, 4 };
            var hs2 = new HashSet<int>() { 3, 4, 5 };
            hs1.ExceptWith(hs2);

            foreach (var i in hs1)
                Console.WriteLine(i.ToString());
        }

        private static void SupersetSubsetExample()
        {
            Console.WriteLine("\nSuperSet SubSet Example");
            var hs1 = new HashSet<int>() { 1, 2, 3, 4 };
            var hs2 = new HashSet<int>() { 2, 3 };

            Console.WriteLine("hs1 is PROPER SUPERSET of hs1: " + hs1.IsProperSupersetOf(hs1));
            Console.WriteLine("hs1 is SUPERSET of hs1: " + hs1.IsSupersetOf(hs1));
            Console.WriteLine("hs1 is PROPER SUPERSET of hs2: " + hs1.IsProperSupersetOf(hs2));
            Console.WriteLine("hs1 is SUPERSET of hs2: " + hs1.IsSupersetOf(hs2));

            Console.WriteLine("hs1 is PROPER SUBSET of hs1: " + hs1.IsProperSubsetOf(hs1));
            Console.WriteLine("hs1 is SUBSET of hs1: " + hs1.IsSubsetOf(hs1));
            Console.WriteLine("hs2 is PROPER SUBSET of hs1: " + hs2.IsProperSubsetOf(hs1));
            Console.WriteLine("hs2 is SUBSET of hs1: " + hs2.IsSubsetOf(hs1));
        }

        private static void SortedSetExample()
        {
            Console.WriteLine("\nSorted Set Example");
            var hs = new HashSet<string>();
            var ss = new SortedSet<string>();

            foreach (var sp in SportsPerson.LoadSportsPerson())
            {
                hs.Add(sp.Name);
                ss.Add(sp.Name);
            }

            Console.WriteLine("\nItems in Hash Set");
            foreach (var s in hs)
                Console.WriteLine(s);

            Console.WriteLine("\nItems in Sorted Set");
            foreach (var s in ss)
                Console.WriteLine(s);
        }

        private static void HashSetExample()
        {
            Console.WriteLine("HashSet Example");
            var hs = new HashSet<string>();
            var list = new List<string>();

            foreach (var sp in SportsPerson.LoadMillionSportsPerson())
            {
                hs.Add(sp.Name);
                list.Add(sp.Name);
            }

            Stopwatch watch = new Stopwatch();
            watch.Start();
            // find something in list
            var contains = list.Contains("Name999999");
            watch.Stop();
            Console.WriteLine("Time taken to search in a list: " + watch.ElapsedMilliseconds);

            watch.Restart();
            //find something in hashset
            contains = hs.Contains("Name999999");
            watch.Stop();
            Console.WriteLine("Time taken to search in a hash set: " + watch.ElapsedMilliseconds);
        }
    }

And here are the results -

Windows Azure - Part 2 - Publishing to Cloud

2011-03-02T20:22:00.001-05:00

In this blog, I will reiterate steps to publish a simple solution to the cloud.
First up, I created a simple website that has a predefined set of quotations and then on the default page, I randomly display a quote. This is very simple because here we are not concerned about the business logic but about how Azure publishing works.

Steps to get ready for publishing from Visual Studio

First we need to create an account at windows.azure.com I have a MSDN subscription so I already have an account.
Then on the management portal, we create a "new Hosted Service" and set some simple properties such as name and location.
Instead of choosing location, it is better to choose an affinity group. An affinity group means that all the servers/VMs will be located in the area that we select as an affinity group.
Once this is done, we create a certificate to ensure that only those who have this certificate are allowed to publish.
We create this cert in VS by going to server explorer and then right-clicking the Windows Azure Compute tab and selecting "Add Deployment Environment".
In this tab, we right click again on "Windows Azure Accounts" and then clicking "New".
On this window, we can create a new cert and then in step 2 we can copy the path of this cert to the clipboard. (picture below)
Then we go back to the management portal and navigate to "Management Certificates" tab. Here we click the "Add Certificate" button.
Here we can copy the path that we copied in the previous step and finish adding the certificate.
Once the cert is added, in the management portal on the right side you will see that an subscription ID is generated.
Copy this subscription ID and go back to VS and paste the id in step 3. Give this cert some name and click OK.
Now go back to Management portal and click on Storage accounts and then click on New Storage account.
Create a new storage account by choosing the same affinity group as chosen above. Its not required but its a good practice to have your storage and app VMs to be near to each other.
Once this is done, we are all set up to publish our solution.

Publishing

Right click on the windows azure project and click on publish.
This will open up an window where you have to select the Credentials, Deployment environment and storage account. All of this, we just created in the steps above.
Once this is done, click on OK and publishing will start.
The publishing takes some time because Azure is actually getting all the instances ready for publishing and then publishing the code out to them.
As publishing progresses, VS also shows a Windows Azure Activity Log - which displays status information about publishing. (shown above)
Once the publishing is done a website URL is provided for you to access your website.
My first cloud app website is located at : http://quotes.cloudapp.net (if you can not access the website, that means, I have brought it down because it costs money to keep it up all the time. So I bring it up only when I am doing some testing for few days. Sorry about that)

LINQ Examples

2011-02-28T01:57:00.005-05:00

In this blog, I will try to create samples of LINQ extension methods which are very helpful in accomplishing things which earlier would take 10-15 lines (or more) of code and were difficult to manage as well as to understand. I will also try to keep this blog as a running list of good LINQ extension methods.
First up, let's see the whole code listing. For my data, I have created a simple SportsPerson class and have populated with arbitrary values.

public class A07LinqExamples
    {
        public static void Run()
        {
            ToLookupExample();

            ToDictionaryExample();
        }

        private static void ToDictionaryExample()
        {
            Console.WriteLine("\n---------ToDictionaryExample-----------------");
            var sportsPersons = LoadSportsPerson();

            // get a dictionary with id as id and value as SportsPerson
            var sportsPersonDict = sportsPersons.ToDictionary(sp => sp.Id, sp => sp);

            // get sportsperson with id 8
            var val = sportsPersonDict[8];
            Console.WriteLine(val.Name + "(" + val.Sport + ")");
        }

        public static void ToLookupExample()
        {
            Console.WriteLine("\n---------ToLookupExample-----------------");
            var sportsPersons = LoadSportsPerson();

            // get a lookup with id as sport and value as list of SportsPerson
            var sportsPersonsCategorized = sportsPersons.ToLookup(sp => sp.Sport, sp => sp);

            // get all sportsperson who play cricket
            foreach (var lkup in sportsPersonsCategorized["Cricket"])
                Console.WriteLine(lkup.Name);
        }

        private static IEnumerable<SportsPerson> LoadSportsPerson()
        {
            return new List<SportsPerson>()
                       {
                           new SportsPerson() {Id = 1, Name = "Sachin Tendulkar", Sport = "Cricket"},
                           new SportsPerson() {Id = 10, Name = "Roger Federer", Sport = "Tennis"},
                           new SportsPerson() {Id = 8, Name = "Rafael Nadal", Sport = "Tennis"},
                           new SportsPerson() {Id = 6, Name = "Pete Sampras", Sport = "Tennis"},
                           new SportsPerson() {Id = 5, Name = "Andre Agassi", Sport = "Tennis"},
                           new SportsPerson() {Id = 4, Name = "Brian Lara", Sport = "Cricket"},
                           new SportsPerson() {Id = 7, Name = "Glenn McGrath", Sport = "Cricket"},
                           new SportsPerson() {Id = 3, Name = "Michael Jordan", Sport = "Basketball"},
                           new SportsPerson() {Id = 9, Name = "Magic Johnson", Sport = "Basketball"},
                           new SportsPerson() {Id = 2, Name = "Steve Nash", Sport = "Basketball"}
                       };
        }
    }

    public class SportsPerson
    {
        public int Id { get; set; }
        public string Name { get; set; }
        public string Sport { get; set; }
    }

ToDictionary
ToDictionary creates a key-value pair from an IEnumerable where all the keys have to be unique. The inputs that you have to provide are obviously the key and the value.

ToLookup
Many a times there is a need to create a lookup structure with some kind of grouping. For example, in our case, we want all sports persons to be categorized based on the sports they play. Lookup provides a simple key-value pair approach where the key can be the sports category and value can be all the sportsperson that belong to that sport. This is very different than dictionary. In a dictionary the key has to be unique. In Lookup keys can be the same.

Result

Encodings

2011-02-20T21:46:00.008-05:00

In this blog post, I will explain how to play around with different types of encodings using C#. I will mainly concentrate on ASCII, UTF-8 and UTF-16.
Character encoding systems consists of a code that pairs each character from a given set into something else, such as numbers.
Different types of encodings
ASCII - works on general english characters. For example, in ASCII capital 'A' is represented by decimal 65 and small 'a' by 97.

UNICODE - works on a broader set of characters. Its a more consistent encoding to represent text expressed by most of the world's writing systems. Unicode is not an encoding. Its a standard. It can be implemented by different character encodings. Most famous being UTF-8 and UTF-16. UTF stands for Unicode Transformation Format.
Difference between UTF-8 and UTF-16 and UTF-32

UTF-8 uses 1 byte at a minimum while UTF-16 uses 2 hence UTF-8 files are generally smaller in size than UTF-16 files.
UTF-8 is backward compatible with ASCII while UTF-16 is not.
Both UTF-8 and UTF-16 are variable-length encodings. That is, its not guaranteed that UTF-8 will always use 1 byte and UTF-16 will always 2 bytes. UTF-16 can use 1 byte or 2 bytes.
UTF-32 is fixed-length encoding. All characters representations take up 4 bytes of space. The advantage of this is that byte arrays are easily indexable. That is, you know that the second character in the array will always start with the 4th byte that is barray[3].
Because every character takes 4 bytes, UTF-32 is space inefficient.

Base-64 Encoding

Base-64 is an encoding scheme to represent binary data in ASCII string format by translating it into radix-64 representation. Base-64 is different from ASCII and Unicode in the sense that Base-64 is not used for representation but more for transportation. To convert a string into base-64 encoded string, we do the following-

Let's take a string "cat".
Converting it into ASCII chars will give us: 99, 97, 116
Represent them in binary: 01100011 01100001 01110100
Combine them: 011000110110000101110100
Pack them in group of 6: 011000 110110 000101 110100
Convert it back to numbers and then to string: "Y2F0"

Code Examples

Let's take a look at some code examples. First up, this is the code-

public class A05Encodings
    {
        public static void Run()
        {
            string str = "水";
            //string str = "cat";

            Console.WriteLine("STRING: " + str);
            
            byte[] bytesAscii = ConvertStrToAscii(str);
            string strAscii = ConvertAsciiToStr(bytesAscii);

            byte[] bytesUTF8 = ConvertStrToUTF8(str);
            string strUTF8 = ConvertUTF8ToStr(bytesUTF8);

            byte[] bytesUnicode = ConvertStrToUnicode(str);
            string strUnicode = ConvertUnicodeToStr(bytesUnicode);

            byte[] bytesUTF32 = ConvertStrToUTF32(str);
            string strUTF32 = ConvertUTF32ToStr(bytesUTF32);

            string base64string = ConvertStrToBase64EncodedString(str);
            string s = ConvertBase64EncodedStringToStr(base64string);
        }

        /* ASCII */
        public static byte[] ConvertStrToAscii(string str)
        {
            Console.WriteLine();
            Console.WriteLine("CONVERT STRING TO ASCII");
            byte[] bytes = Encoding.ASCII.GetBytes(str);
            PrintBytes(bytes);
            return bytes;
        }

        public static string ConvertAsciiToStr(byte[] bytes)
        {
            Console.WriteLine();
            Console.WriteLine("CONVERT ASCII TO STRING");
            string str = Encoding.ASCII.GetString(bytes);
            Console.WriteLine(str);
            return str;
        }

        /* UTF-8 */
        private static byte[] ConvertStrToUTF8(string str)
        {
            Console.WriteLine();
            Console.WriteLine("CONVERT STRING TO UTF-8");
            byte[] bytes = Encoding.UTF8.GetBytes(str);
            PrintBytes(bytes);
            return bytes;
        }

        private static string ConvertUTF8ToStr(byte[] bytes)
        {
            Console.WriteLine();
            Console.WriteLine("CONVERT UTF-8 TO STRING");
            string str = Encoding.UTF8.GetString(bytes);
            Console.WriteLine(str);
            return str;
        }

        /* UNICODE = UTF-16 */
        private static byte[] ConvertStrToUnicode(string str)
        {
            Console.WriteLine();
            Console.WriteLine("CONVERT STRING TO UNICODE=UTF-16");
            byte[] bytes = Encoding.Unicode.GetBytes(str);
            PrintBytes(bytes);
            return bytes;
        }

        private static string ConvertUnicodeToStr(byte[] bytes)
        {
            Console.WriteLine();
            Console.WriteLine("CONVERT UNICODE=UTF-16 TO STRING");
            string str = Encoding.Unicode.GetString(bytes);
            Console.WriteLine(str);
            return str;
        }

        /* UTF-32 */
        private static byte[] ConvertStrToUTF32(string str)
        {
            Console.WriteLine();
            Console.WriteLine("CONVERT STRING TO UTF-32");
            byte[] bytes = Encoding.UTF32.GetBytes(str);
            PrintBytes(bytes);
            return bytes;
        }

        private static string ConvertUTF32ToStr(byte[] bytes)
        {
            Console.WriteLine();
            Console.WriteLine("CONVERT UTF-32 TO STRING");
            string str = Encoding.UTF32.GetString(bytes);
            Console.WriteLine(str);
            return str;
        }

        /* Base 64 Encoding */
        private static string ConvertStrToBase64EncodedString(string str)
        {
            Console.WriteLine();
            Console.WriteLine("CONVERT STRING TO BASE-64 ENCODING");
            byte[] bytes = Encoding.ASCII.GetBytes(str);
            string base64str = Convert.ToBase64String(bytes);
            Console.WriteLine(base64str);
            return base64str;
        }

        private static string ConvertBase64EncodedStringToStr(string str)
        {
            Console.WriteLine();
            Console.WriteLine("CONVERT STRING TO BASE-64 ENCODING");
            byte[] bytes = System.Convert.FromBase64String(str);
            string s = Encoding.ASCII.GetString(bytes);
            Console.WriteLine(s);
            return s;
        }

        /* HELPERS */
        private static void PrintBytes(byte[] bytes)
        {
            foreach (byte b in bytes)
            {
                Console.Write(b);
                Console.Write("  ");
            }
            Console.WriteLine();
            Console.WriteLine("LENGTH: " + bytes.Length);
        }
    }

When I run with the string as "cat". These are the results -

When I run with the string as "水". These are the results -

In this case, ASCII can not represent this character hence the results for ASCII, UTF-8 and Base-64 encoding are wrong since they are actually for string "?".

Storing BLOBs, CLOBs and XML in SQL

2011-02-20T15:50:00.006-05:00

In this blog post, I will explore how to use OPENROWSET in SQL to perform operations for BLOBS, CLOBS, external XML files etc.
Storing BLOBs
BLOBs are binary large objects. To store BLOBs we will use the OPENROWSET keyword in SQL. Let's take a look at the SQL first.

declare @BlobTable table(blob_path varchar(150), blob_storage varbinary(max))
insert into @BlobTable (blob_path, blob_storage)
select 'C:\abc.txt' ,
* from openrowset(bulk 'C:\abc.txt', single_blob) as document
select * from @BlobTable

First we create a table to hold the blob object. This column is of type varbinary(max) and then we insert the file text into this column using OPENROWSET. The option single_blob returns the contents as single row, single column rowset of type varbinary(max).

Storing CLOBs
CLOBs are character large objects. To store CLOBs we will again use the OPENROWSET keyword in SQL. The SQL statement looks like -

declare @ClobTable table(clob_path varchar(150), clob_storage varchar(max))
insert into @ClobTable (clob_path, clob_storage)
select 'C:\abc.txt' ,
* from openrowset(bulk 'C:\abc.txt', single_clob) as document
select * from @ClobTable

The only 2 differences between this statement and the one above is that here the clob_storage is defined as varchar(max) and the option provided to OPENROWSET is single_clob. The option single_clob returns the contents as single row, single column rowset of type varchar(max). It reads the file provided in ASCII.

Storing NCLOBs
The only difference between storing CLOB and NCLOB is that the datatype used is nvarchar(max) and the file should be saved with UNICODE encoding. The SQL statement looks like:

declare @NClobTable table(clob_path varchar(150), clob_storage nvarchar(max))
insert into @NClobTable (clob_path, clob_storage)
select 'C:\abcUnicode.txt' ,
* from openrowset(bulk 'C:\abcUnicode.txt', single_nclob) as document
select * from @NClobTable

Inserting/Updating XML from file
MSDN website says that we should import xml data using the single_blob option only, rather than single_clob and single_nclob option as only single_blob option supports all windows encoding conversions. Let's take a look at an example

declare @New_varbinary varbinary(max)
set @New_varbinary = (select * from openrowset(bulk 'C:\abc.xml', single_blob) as document)
update TableWithXmlColumn 
set TheXmlColumn = @New_varbinary
where SomeId = 1653

Difference between varbinary, varchar, nvarchar
nvarchar is used to store UNICODE data while varchar is used to store ASCII data. We should use nvarchar if the database requirements are for multilingual support. This will allow for extended set of characters. If the data stored not need any multilingual support than we should use varchar. The reason being nvarchar uses twice as much space as varchar to support extended character codes. These data types in SQL are categorized in different categories: varbinary belongs to binary strings category. varchar belongs to character strings category and nvarchar belongs to Unicode character strings.

Windows Azure - Part 1 - Overview

2011-02-20T11:27:00.003-05:00

In this blog post, I will cover the basics of Windows Azure and cloud computing.
Cloud Computing: Cloud computing is about abstracting out the infrastructure needs for your application. So that you don't have to worry about scalability, server management, patches, updates etc. You also pay for the resources you use.
Windows Azure consists of 3 components -

Compute - consists of the VMs that have high computing capacities
Storage - for storing images/large files etc
Management - an API to manage the needs for your application

SQL Azure provides all the SQL database capabilities in a highly scalable manner.

Architecture

At the first level, we have Loadbalancers which assist in scaling. The second layer is called Fabric. This consists of server instances that are running your application. They can have Web roles or Worker roles. The fabric layer talks to Storage layer via another set of Loadbalancers. The storage layer consists of tables, blobs etc. There is one another component which cuts across multiple layers. This is called Fabric Controller. This is the controller that manages the whole environment. If one server goes down, Fabric controller chooses another one so that the application is not down. This is the advantage that we get from cloud computing.
So, I went ahead and added a windows azure project with one web role, one worker role.

Web Role:

Web role provides a web front end for our application.
WebRole.cs file provides the entry point for this web app. Here we can override the OnStart() etc methods.
These methods are called even before the Global.asax methods.

Worker Role:

Worker role is similar to windows service in the sense that it is running in the background and it can listen to events or it can poll and execute certain tasks.
WorkerRole.cs file provides the entry point to this worker process.
Here you can override the OnStart(), Run() methods etc.
The Run() method consists of a while (true) statement. It is in this while loop that we can write our code for the worker process to execute.

Windows Azure Project:

This project provides the cloud settings for the roles mentioned above.
Here you can control the number of instances, size of VM, settings, certificates, Virtual networks, storage etc.
The difference between these settings file and web.config is that you can make changes to these settings file and they will be picked up by the web role or worker role automatically. In case of web.config, you need to deploy the new web.config and restart IIS or redeploy the app for the changes to take effect.

When you run this app, a package is created and then deployed. The website starts to run but the point to notice here is that the website is not running in your IIS or localhost but in another environment called developer fabric. If you see on the right lower side of your screen, you will see that 2 small icons for Compute emulator and Storage emulator have appeared. If you look at these emulators you can see the trace logs, the state in which instances are and can do the monitoring jobs.

Dynamic keyword in C#

2011-02-16T22:19:00.002-05:00

In this blog post, I will try to understand the dynamic keyword that was introduced in C# 4.0. These notes are from Alexandra Rusina's article.
Usually dynamic languages such as JavaScript, Ruby, Python etc don't perform compile time checks therefore no compile time errors. C# and Java are considered to be statically typed languages that's why we get the compilation errors and intellisense. To enhance interoperability between dynamic and static languages, a keyword dynamic was added in C#. This keyword tells the compiler to turn off the compile time checking.
object work the same way, but to perform explicit type operations you have to explicitly cast the object to that specified type first.
var keyword also works similarly but the difference is that you can not change the type of var at runtime.
Reflection
Earlier to read objects from different systems, we had to rely on reflection to read the objects and its members and properties. This kind of code was tough to read. Dynamic makes it a bit easier.
Dynamic Method Bags
Dynamic method bags are objects that are created at run time and they can add or remove properties and methods.
Please see the following code which provides examples for the topics discussed above.

public class TV
    {
        public void Show(string str)
        {
            Console.WriteLine(str);
        }
    }

    public class A04DynamicKeyword
    {
        internal static void Run()
        {
            dynamic d = "sachin tendulkar";
            Console.WriteLine(d.GetType());
            
            // this will compile because its dynamic so type information is not known
            // but at runtime this will fail
            //d++;

            d = 100;
            Console.WriteLine(d.GetType());

            // this will work
            d++;
            Console.WriteLine(d);

            object obj = "sachin tendulkar";
            Console.WriteLine(obj.GetType());

            obj = 100;
            Console.WriteLine(obj.GetType());

            // for object explicit cast has to be used
            obj = (int) obj + 1;
            Console.WriteLine(obj);

            var v = 1000;
            Console.Write(v.GetType());

            v++;
            Console.WriteLine(v);

            // this will throw compiler error
            // we can not change the type of var once its fixed
            //v = "sachin tendulkar";

            //reflection was tough to code and not intuitive
            object tvObj = GetTV();
            Type type = tvObj.GetType();
            type.InvokeMember("Show", BindingFlags.InvokeMethod, null, tvObj, new object[] {"Show from Object"});
            
            // dynamic is easy and intuitive
            dynamic tv = GetTV();
            tv.Show("Dynamic Show");

            // Dynamic Class
            dynamic expandoObj = new ExpandoObject();
            expandoObj.FlyProperty = "This property is added on fly";
            expandoObj.SomeMethod = (Action) (() => Console.WriteLine(expandoObj.FlyProperty));
            expandoObj.SomeMethod();

        }

        private static TV GetTV()
        {
            return new TV();
        }
    }

And here are the results

Singleton Pattern

2011-02-03T01:45:00.008-05:00

In this blog post, I will try to create an example demonstrating the usage of singleton pattern.
When:

for situations where you only need one and only one object to exist
class needs to be accessible to clients
class should not require any parameters for its object creation
if creating an object is expensive, singleton can be useful

How:
In this example, we will try to create a LoadBalancer. LoadBalancer monitors the memory, processor resources etc and then decides which server to assign a particular task to. We won't create all those details as they are not necessary for this demonstration. Instead, we will use the C# Random class to make that decision. Why we need singleton pattern in this case? Because we don't want multiple instances of LoadBalancer. There should only be one LoadBalancer who makes the decision about multiple servers. Let's take a look at the consumer code first:

static void Main(string[] args)
        {
            SingletonPatternExample();

            Console.ReadLine();
        }

        private static void SingletonPatternExample()
        {
            for (int i = 0; i < 20; i++)
            {
                LoadBalancer lb = LoadBalancer.GetLoadBalancer();
                Console.WriteLine("Task " + i + " is assigned to " + lb.Server);
                System.Threading.Thread.Sleep(1000);
            }
        }

In this code, I just have a simple for loop to imitate tasks coming in. For every task, we get the LoadBalancer object and assign the Server to it randomly. For this example, you can argue that we could have achieved the same result by declaring the LoadBalancer object outside the for loop. That is true, but that is not the point of this demo. The point here is that singleton pattern is proactively stopping any new instances being created. Let's take a look at the LoadBalancer class now.

sealed class LoadBalancer
    {
        // Static members are lazily initialized. 
        // .NET guarantees thread safety for static initialization 
        private static readonly LoadBalancer instance = new LoadBalancer();

        private ArrayList servers = new ArrayList();
        private Random random = new Random();

        // Note: constructor is private.
        private LoadBalancer()
        {
            // List of available servers 
            servers.Add("Server 1");
            servers.Add("Server 2");
            servers.Add("Server 3");
            servers.Add("Server 4");
            servers.Add("Server 5");
        }

        public static LoadBalancer GetLoadBalancer()
        {
            return instance;
        }

        // Simple, but effective load balancer 
        public string Server
        {
            get
            {
                int r = random.Next(servers.Count);
                return servers[r].ToString();
            }
        }
    }

The class is sealed so that it can not be inherited. Then we define a LoadBalancer instance as private and as static. If you don't define it a static then its not thread-safe. The class also has an ArrayList of servers and a Random object. The class also has a private constructor which just adds the servers to the ArrayList. Private constructor makes sure that class can not be initialized outside the scope. The GetLoadBalancer() method returns the one and only instance. There is no other way to get hold of this instance. And lastly, the simple Server property does the main work of finding out a Server and then notifying it to the caller.
Here are the results:

Factory Pattern

2011-02-01T01:22:00.012-05:00

In this blog post, I will try to create a simple program which will demonstrate the utility and significance of the factory pattern.
When:

when many classes are implementing an interface and you are unsure about which concrete implementation to return
when you want to separate creation logic from the object's main goal like when creating an object if you want to assign values to many properties and you want to separate this kinda logic from object's main functionality
if there are many if-else or switch statements for deciding which object to create

Why:

to encapsulate the creation of object
to separate the creation of object from the decision about which object to create
to allow adding new objects without breaking open closed principle (classes should be open for extension, closed for modification)
to allow (if needed) storing which objects to create in a separate place like database or configuration

How:

Let's create an example to see how factory pattern works. Let's say that we have a consumer which wants to perform search. The consumer doesn't care about which actual search engine does the search, as long as it can perform the search. From a factory perspective, we have multiple search providers and we want some kind of configuration to switch the providers. Let's take a look at the consumer code first.

class Program
{
        static void Main(string[] args)
        {
            ISearchEngineFactory factory = LoadFactory();

            ISearchEngine engine = factory.CreateMapSearchEngine();
            engine.Search();

            engine = factory.CreateNormalSearchEngine();
            engine.Search();

            Console.ReadLine();
        }

        private static ISearchEngineFactory LoadFactory()
        {
            string factoryName = Properties.Settings.Default.SearchFactory;
            return Assembly.GetExecutingAssembly().CreateInstance(factoryName) as ISearchEngineFactory;
        }
    }

In this code, first we create a factory by calling the LoadFactory() method. This method looks into the settings file to see which factory to load and then by using reflection creates an instance of that factory. The ISearchEngineFactory defines two methods as shown below: one for normal search and the other for map search.

public interface ISearchEngineFactory
{
        ISearchEngine CreateNormalSearchEngine();

        ISearchEngine CreateMapSearchEngine();
    }

In this example, we are defining two search engines: Google and Bing. So, first up, we create 2 factories for them as shown below:

public class GoogleFactory : ISearchEngineFactory
{
        public ISearchEngine CreateNormalSearchEngine()
        {
            return new Google() as ISearchEngine;
        }

        public ISearchEngine CreateMapSearchEngine()
        {
            Google g = new Google {Context = "Maps"};
            return g as ISearchEngine;
        }
    }

public class BingFactory : ISearchEngineFactory
{
        public ISearchEngine CreateNormalSearchEngine()
        {
            return new Bing() as ISearchEngine;
        }

        public ISearchEngine CreateMapSearchEngine()
        {
            return new BingMaps() as ISearchEngine;
        }
    }

In this example, we are also demonstrating, how the actual object creation can be different. The Bing engine returns Bing object for normal searches and BingMaps object for map searches. The Google engine for normal search, just returns the Google object with context as null. For maps search, it returns the normal google object with Context set as "Maps". All of these engines, implement the ISearchEngine interface which has a Search method and a context property as shown below.

public interface ISearchEngine
{
        void Search();

        string Context { get; set; }
    }
public class Bing : ISearchEngine
{
        public void Search()
        {
            Console.WriteLine("You searched on Bing");
        }

        public string Context { get; set; }

    }
public class BingMaps : ISearchEngine
{
        public void Search()
        {
            Console.WriteLine("You searched on Bing Maps");
        }

        public string Context { get; set; }
    }
public class Google : ISearchEngine
{
        public void Search()
        {
            string str = "You searched on Google";

            if (string.IsNullOrEmpty(Context))
                Console.WriteLine(str);
            else
                Console.WriteLine(str + " " + Context);
        }

        public string Context { get; set; }
    }

When you run this app, with search provider set as Google, you see the following output.

And if you go to settings page and change the settings configuration to use Bing as the search provider, the output is as below:

Once we have set up the factory pattern in our code, we can easily add newer factories and newer search engine classes without affecting any of the other classes, hence respecting the Open-Closed principle. Once that is done, you can easily change the configuration to point to say Yahoo factory and the factory pattern will take care of correct object creations.

Migration from 32bit to 64bit Projects in .NET

2011-01-21T01:23:00.001-05:00

In this blog post, I am going to explain the solution for a few issues that I had working with 32bit and 64 bit Operating systems and what we should do to create applications that would work without any code changes in any environments.
If you go to project properties and then navigate to Build tab, you will see a dropdown for Platform target. By default, this value is set to "Any CPU". You can change it to specifically target x86 (32bit) and x64 (64bit) environments.
So, first I created 3 projects. Lets call them -

A - Console app. This will be the startup project and hence the calling assembly.
B - Class library. A just calls a method in a class in B.
C - Class library. B just calls a method in a class in C.

So when we run the app, it will work on both 32bit and 64bit OSs because by default the target was set to "Any CPU". So if all this works then why this blog?

In this example, we had the code for all three DLLs. Sometimes, our code refers to other DLLs, on which we have no control. Recently in one of the projects I was working, we were referencing SQL CE v3.0 DLLs which worked only on 32bit environment. This case can be recreated by changing B's target platform to x86 and running the program on a 64bit machine. What will happen in this case is -

A is "AnyCPU" and machine is 64bit so A would be running in 64bit environment
A will call a method in a class inside B.
B is "x86" so it will not run in 64bit.
So now, a 64bit DLL is calling a 32bit DLL. This is not allowed and an error will be thrown.

What is the resolution? We have 3 -

If you have the code for B, you can change the platform target for B from x86 to "AnyCPU"
If you don't have code for B, then you can try to search for a 64bit version of B's assembly
If this also doesn't work, you can simply change the calling assembly i.e. A's platform target to "x86" and the app will work.

Reading a web page

2011-01-16T15:47:00.002-05:00

Many times there is a need to read a web page programatically. That is, get the html through code and parse through it to search what you want. Codeplex has a DLL named HTML Agility Pack (HAP) that comes to our rescue.
Download the DLL and then add a reference to it in your application. The DLL allows us to access the html code from the url provided and then exposes a DOM for us to navigate through. With HAP you can read, search, modify and save the web pages. Of course, modifications and save will only result in a local file and not persist the changes on the web page itself.
In this blog, we will create two methods: one to get all the meta tags on the web page and the other to get all the links on the page. The code is shown below:

private void btnGetMetaTags_Click(object sender, RoutedEventArgs e)
        {
            tbResult.Text = string.Empty;
            var webGet = new HtmlWeb();
            var document = webGet.Load(tbUrl.Text);

            var metaTags = document.DocumentNode.Descendants("meta");

            if (metaTags != null)
            {
                foreach (var tag in metaTags)
                {
                    if (tag.Attributes["name"] != null && tag.Attributes["content"] != null)
                    {
                        tbResult.Text += "Name: " + tag.Attributes["name"].Value + Environment.NewLine;
                        tbResult.Text += "Content: " + tag.Attributes["content"].Value + Environment.NewLine;
                        tbResult.Text += Environment.NewLine;
                    }
                }
            }
        }

        private void btnGetAllLinks_Click(object sender, RoutedEventArgs e)
        {
            tbResult.Text = string.Empty;
            var webGet = new HtmlWeb();
            var document = webGet.Load(tbUrl.Text);

            var linksOnPage = document.DocumentNode.Descendants("a");

            foreach (var lnk in linksOnPage)
            {
                if (lnk.Attributes["href"] != null && lnk.InnerText.Trim().Length > 0)
                {
                    tbResult.Text += "URL: " + lnk.Attributes["href"].Value + Environment.NewLine;
                    tbResult.Text += "InnerText: " + lnk.InnerText.Trim() + Environment.NewLine;
                    tbResult.Text += Environment.NewLine;
                }
            }
        }

In the code, first we create and load a HtmlWeb document from the supplied url. Then we access its DocumentNode property and use LINQ to further access all the descendants.
Once you run the application and click on "Get Meta Tags" button, you get the following result:

When you click on the "Get all links on the page" button, you get the following result:

You can also modify the results in a similar fashion and then save them by calling the Save method of the document.

Saving Application State in Windows Phone 7

2011-01-06T21:20:00.008-05:00

In the last post, I created a small app to store the page state. In this blog post, I will try to create an app that stores some counters across the application lifetime. We will store two counters: 1. How many times this app was used 2. Last datetime this app was used.
We will create a simple app using the MVVM pattern. First up, lets take a look at the ViewModel called CounterViewModel.

public class CounterViewModel : INotifyPropertyChanged
    {
        public event PropertyChangedEventHandler PropertyChanged;

        private void OnPropertyChanged(string propertyName)
        {
            if (PropertyChanged != null)
                PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
        }

        private int m_AppCounter;
        public int AppCounter
        {
            get
            {
                return m_AppCounter;
            }
            set
            {
                if (m_AppCounter != value)
                {
                    m_AppCounter = value;
                    OnPropertyChanged("AppCounter");
                }
            }

        }

        private DateTime m_LastVisit;
        public DateTime LastVisit
        {
            get
            {
                return m_LastVisit;
            }
            set
            {
                if (m_LastVisit != value)
                {
                    m_LastVisit = value;
                    OnPropertyChanged("LastVisit");
                }
            }
        }

        public DateTime SessionStartTime { get; set; }
    }

The ViewModel implements the INotifyPropertyChanged interface to update UI whenever properties change. AppCounter is to store the number of times this app is used. LastVisit is to display the time this app was last used. SessionStartTime is a variable to store current time when this app was launched/activated. When we close/deactivate the app, we change the LastVisit to store SessionStartTime. Now, lets take a look at the App.Xaml where we supply values to these variables:

public static CounterViewModel CounterViewModel { get; set; }

private void Application_Launching(object sender, LaunchingEventArgs e)
{
       CounterViewModel = CounterRepository.GetCounters();
       CounterViewModel.AppCounter++;
       CounterViewModel.SessionStartTime = DateTime.Now;
}

private void Application_Activated(object sender, ActivatedEventArgs e)
{
    CounterViewModel.AppCounter++;
    CounterViewModel.SessionStartTime = DateTime.Now;
    CounterViewModel = CounterRepository.GetCounters();
}

private void Application_Deactivated(object sender, DeactivatedEventArgs e)
{
    CounterViewModel.LastVisit = CounterViewModel.SessionStartTime;
    CounterRepository.SaveCounters(CounterViewModel);
}

private void Application_Closing(object sender, ClosingEventArgs e)
{
    CounterViewModel.LastVisit = CounterViewModel.SessionStartTime;
    CounterRepository.SaveCounters(CounterViewModel);
}

First, we add a static variable for the ViewModel in the app.xaml class. This static object will store our counters. In the Launching/Activated method, we get the counters from our store (we will see that in a bit). We increase the app counter and store the current time in SessionStartTime. In the Closing/Deactivated, we assign the LastVisit variable to store SessionStartTime and then we save the counters. We should be careful about what code we put in Launching/Activated methods, as there is a time limit of 10 secs. If within 10 seconds these methods don't finish execution, an exception is thrown.
The CounterRepository class code is shown below:

public class CounterRepository
    {
        internal static CounterViewModel GetCounters()
        {
            if (PhoneApplicationService.Current != null
                && PhoneApplicationService.Current.State.ContainsKey("counterViewModel")
                && PhoneApplicationService.Current.State["counterViewModel"] is CounterViewModel)
            {
                return PhoneApplicationService.Current.State["counterViewModel"] as CounterViewModel;
            }
            else
            {
                IsolatedStorageFile store = IsolatedStorageFile.GetUserStoreForApplication();

                if (store.DirectoryExists("data") && store.FileExists("data\\counters.xml"))
                {
                    using (var file = store.OpenFile("data\\counters.xml", FileMode.Open))
                    {
                        var serializer = new XmlSerializer(typeof(CounterViewModel));
                        var result = serializer.Deserialize(file);
                        return result as CounterViewModel;
                    }
                }
                else
                {
                    return new CounterViewModel()
                    {
                        AppCounter = 0
                    };
                }
            }
        }

        internal static void SaveCounters(CounterViewModel cvm)
        {
            SaveToPhoneApplicationService(cvm);
            SaveToIsolatedStorage(cvm);
        }

        private static void SaveToPhoneApplicationService(CounterViewModel cvm)
        {
            if (PhoneApplicationService.Current != null)
                PhoneApplicationService.Current.State["counterViewModel"] = cvm;
        }

        private static void SaveToIsolatedStorage(CounterViewModel cvm)
        {
            IsolatedStorageFile store = IsolatedStorageFile.GetUserStoreForApplication();

            if (!store.DirectoryExists("data"))
                store.CreateDirectory("data");

            if (store.FileExists("data\\counters.xml"))
                store.DeleteFile("data\\counters.xml");

            using (var file = store.CreateFile("data\\counters.xml"))
            {
                var serializer = new XmlSerializer(typeof(CounterViewModel));
                serializer.Serialize(file, cvm);

                file.Flush();
                file.Close();
            }
        }
    }

In the SaveCounters method, we take care of both tombstoning and closing the application cases. In case, user moves away from your app by opening a browser, application is not closed but deactivated. This is called tombstoning. In case, the user presses a back button, the application is closed. In case of tombstoning, we have the option of using PhoneApplicationService. This class provides access to various aspects of Application lifetime. In case the application is closed, PhoneApplicationService will not exist. So we use the concept of IsolatedStorage to store the variables outside of the application in phone's memory store. We create a folder to store the data. Then we take the ViewModel and serialize to get an xml file, which is then stored into the folder.
In the GetCounters method, we do the reverse. We first check if the counters are available in the PhoneApplicationService. If they are not, we fetch the counters from IsolatedStorage.
Lastly, lets take a look at the XAML file, which is pretty simple.

<Grid x:Name="ContentPanel" Grid.Row="1">
            <Grid.RowDefinitions>
                <RowDefinition Height="Auto" />
                <RowDefinition Height="Auto"/>
            </Grid.RowDefinitions>
            <Grid.ColumnDefinitions>
                <ColumnDefinition />
                <ColumnDefinition />
            </Grid.ColumnDefinitions>
            <TextBlock Grid.Row="0" Grid.Column="0" FontSize="24" Text="App Counter: " />
            <TextBlock Grid.Row="0" Grid.Column="1" FontSize="24" Text="{Binding Path=AppCounter}" />
            <TextBlock Grid.Row="1" Grid.Column="0" FontSize="24" Text="Last Visit: "/>
            <TextBlock Grid.Row="1" Grid.Column="1" FontSize="24" Text="{Binding Path=LastVisit}" />
        </Grid>

In the cs file, we just set the DataContext property to the ViewModel. And then in the XAML, we bind the TextBlocks to display these values.
When we start the app, you see the count as 1 and datetime as default datetime. This can be easily changed to probably show no last visit date. This scenario is displayed in image 1. Then, click the hardware search button to depict the Deactivated case. Image 2 shows the search screen that comes up. Then click the hardware back button to go back to the app and activate it. As you can see in image 3, the counter has increased and last visit datetime has changed. In this case, these values were stored in the PhoneApplicationService. Then, click on the hardware back button again to depict the closing case. The application is closed and you see image 4. Once you click the AppCounter app, you again see the results as in image 5.


1	2	3	4	5

Saving Page State in Windows Phone 7

2011-01-04T04:36:00.011-05:00

In this blog post, I will try to create a sample app in which we store the page state. By default, once you move away from your windows phone app, the page state is not stored. We need to take measures to store the page state when deactivating and restore the page state when activating.
Read on to see the code snippets and explanation -
Let's look at the XAML first -

<Grid x:Name="ContentPanel" Grid.Row="1" Margin="12,0,12,0">
    <StackPanel>
         <TextBlock Text="Move the slider" />
         <Slider x:Name="sl" Maximum="100" Minimum="0" />
         <TextBox x:Name="tb" Text="{Binding ElementName=sl, Path=Value, Mode=TwoWay}" ></TextBox>
    </StackPanel>
</Grid>

In this XAML, I just have one slider and a textbox bound to slider value, so that it gives us a visual representation of the slider value. The Mode is TwoWay so I can update the value in textbox and slider will position itself accordingly.

Let's take a look at the .cs file now -

public partial class MainPage : PhoneApplicationPage
    {
        bool isNewInstance = false;
        public MainPage()
        {
            InitializeComponent();
            isNewInstance = true;
        }

        protected override void OnNavigatedFrom(System.Windows.Navigation.NavigationEventArgs e)
        {
            base.OnNavigatedFrom(e);

            PageStateSaver.PreserveSliderState(this.State, this.sl);

            isNewInstance = false;

            this.State["PreservingPageState"] = true;
        }

        protected override void OnNavigatedTo(System.Windows.Navigation.NavigationEventArgs e)
        {
            base.OnNavigatedTo(e);

            if (isNewInstance && this.State.ContainsKey("PreservingPageState"))
            {
                PageStateSaver.RestoreSliderState(this.State, this.sl, 0.0);
            }
        }
    }

In this code, we have overridden two events. OnNavigatedFrom is called when you are navigating away from the application. In this method, we store the state of slider. OnNavigatedTo is called when we are navigating back to the application. In this method, we restore the state of the slider. PageStateSaver is a static class with these helper methods. Let's take a look at the class code-

public static class PageStateSaver
    {
        internal static void PreserveSliderState(System.Collections.Generic.IDictionary<string, object> state, Slider slider)
        {
            state[slider.Name + "_Value"] = slider.Value;
        }

        internal static void RestoreSliderState(System.Collections.Generic.IDictionary<string, object> state, Slider slider, double defaultVal)
        {
            slider.Value = TryGetValue<Double>(state, slider.Name + "_Value", defaultVal);
        }

        private static T TryGetValue<T>(IDictionary<string, object> state, string name, T defaultValue)
        {
            if (state.ContainsKey(name))
            {
                if (state[name] != null)
                    return (T)state[name];
            }
            return defaultValue;
        }
    }

In PreserveSliderState method, we are passing the page's state and the control itself. As you can see, page's state is nothing but a dictionary of string keys and object values. We create our own key and save the slider value object. In RestoreSliderState, we do the opposite. I just copied the TryGetValue code from MSDN, so that when we had multiple controls, we can use the same generic method.
Let's see the results. Image 1 below shows the screen when you startup.

Move the slider or put a number between 0 and 100 in the textbox and tab out to move out of textbox. This will change the slider value. I changed the value to 50 as shown in the image 2 (BTW, if you press pg up in the emulator, you can use the keyboard to type in values)
Now click on the search button below. This will call the OnNavigatedFrom method and the state will be stored. The search screen will look something similar to image 3.
Now press the back button. When you press the back button, OnNavigatedTo method is called and the state will be restored. The screen will now look exactly as the second image (image 4).
If you comment the OnNavigatedTo and OnNavigatedFrom methods and try this scenario again, you will see that the page state is not stored.
I also found a useful DLL to look at the counters by following steps in the link here .

IValueConverter Example

2011-01-03T23:20:00.000-05:00

WPF and Silverlight extensively use XAML and data binding. Sometimes, such scenarios come up where we need to bind a control to a property but the property value needs to be converted to something which makes sense for the control. That's where IValueConverter comes in.
We will try to create a Windows Phone app where if you enter a number between 1 to 7, a textbox will show the weekday names. 1 is Monday and 7 is Sunday. Let's take a look at the xaml first.

<phone:PhoneApplicationPage.Resources>
        <src:DayNumConverter x:Key="DayConverterKey"/>
    </phone:PhoneApplicationPage.Resources>
    
    <Grid x:Name="LayoutRoot" Background="Transparent">
        <Grid.RowDefinitions>
            <RowDefinition Height="Auto"/>
            <RowDefinition Height="*"/>
        </Grid.RowDefinitions>

        <StackPanel x:Name="TitlePanel" Grid.Row="0" Margin="12,17,0,28">
            <TextBlock x:Name="ApplicationTitle" Text="MY APPLICATION" Style="{StaticResource PhoneTextNormalStyle}"/>
            <TextBlock x:Name="PageTitle" Text="page name" Margin="9,-7,0,0" Style="{StaticResource PhoneTextTitle1Style}"/>
        </StackPanel>

        <Grid x:Name="ContentPanel" Grid.Row="1" Margin="12,0,12,0">
            <StackPanel>
                <TextBlock Text="Enter a number in the range of 1 to 7"/>
                <TextBox x:Name="tbDayNum"/>
                <TextBlock x:Name="tb" Text="{Binding Path=Text, ElementName=tbDayNum, Converter={StaticResource DayConverterKey}}"/>
            </StackPanel>
        </Grid>
    </Grid>

Here, first up, we have created a static resource and assigned it a key. Then we bind the textblock's text property to textbox's text property and apply a converter to it. The code for converter class is shown below:

public class DayNumConverter : IValueConverter
    {
        public object Convert(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)
        {
            if (value == null)
                return "No Day Selected";

            string str = value.ToString();
            if (string.IsNullOrEmpty(str))
                return "No Day Selected";

            int num = 0;
            if (Int32.TryParse(str, out num))
            {
                switch (num)
                {
                    case 1:
                        return "Monday";
                    case 2:
                        return "Tuesday";
                    case 3:
                        return "Wednesday";
                    case 4:
                        return "Thursday";
                    case 5:
                        return "Friday";
                    case 6:
                        return "Saturday";
                    case 7:
                        return "Sunday";
                    default:
                        return "Not a valid number";
                }
            }
            else
            {
                return "Not a valid number";
            }
        }

        public object ConvertBack(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)
        {
            throw new NotImplementedException();
        }
    }

This class does nothing but implements the IValueConverter interface. This means that everytime binding will take place, the value will be passed to this converter class before binding it to control's value. If you run the app you will see the following results:

Windows Phone 7 - Overview

2011-01-03T21:33:00.009-05:00

Happy New Year 2011!!
In this blog post, I will take a look at Windows Phone 7 and how to develop an application for this platform. Why should we develop for Windows Phone 7 -

There is a huge market for mobile apps
Consumers expect all of their apps (even business apps) to have mobile components

A Windows Phone 7 has 6 hubs. A hub is nothing but a kind of grouping for items that are related. The 6 hubs are -

People
Office
Pictures
Music + Video
Marketplace
Games

Framework Components

At the core of the framework is common base class library. On top of it is Application Object which provides common application features such as application management, session etc. On top of this are 2 components - Silverlight and XNA. As you know, XNA is mostly for games development and Silverlight for mostly apps development. On top of this resides a set of windows phone frameworks -

PhoneApplicationFrame - core of UI
PhoneApplicationPage - core of UI
PushNotification - enables your app to receive notification even if they are not running. Currently, windows phone doesn't allow multitasking but PushNotification can still work because it doesn't require the app to be running.
WebBrowserControl - to access web, so that users don't have to close the app to browse web
Sensors
Camera
DeviceIntegration
Launchers and Choosers - enables you to interact with some of the phone's native applications like media player.
Windows Phone Controls - Textbox, images, media element etc

WMAppManifest.xml file

This manifest defines the capabilities for an application. By using the capability detection tool, this list can be condensed to just keep the capabilities required by the app.
In here we also specify the default page to load in the DefaultTask element.
It also defines other properties such as background image and icon for the application.
You can not define the splash screen image in the manifest as the splash screen image loads before the manifest.
Some other properties that will come up in the market place (author, description, title etc) can be defined in the App element.

Application Events

These are defined in the App.xaml
Application_Launching/Closing - when the application is launched/closed.
Application_Deactivated - When app get tombstoned (user has moved away say by opening a browser or something else)
Application_Activated - When you return back to the app
Activated, Deactivated don't get called while Launching, Closing respectively.

Panorama Application

Idea behind panorama applications is that in this UI is a long horizontal space in which controls are placed. This space is bigger than the screen size and you can continously go farther and farther on the right side as you make choices.

The guidance suggests that you should have minimum of 3 items in the panorama control.

Also, the guidance suggests that you should not use an application bar with panorama control.

Panorama is a control which can then contain multiple PanoramaItem. Each PanoramaItem can then contain other controls that you want to show as part of the item.

By default, Panorama application projects implement Model-View-ViewModel pattern.

Pivot Application

Idea behind pivot applications is that in this UI the controls keep on rotating like in a circle.

Pivot is a control which can then contain multiple PivotItem. Each PivotItem can then contain other controls.

Pivots can have application bars.

By default, pivot application project implements Model-View-ViewModel pattern.

Application States

Launching
Running
Closing
Deactivated
Activated

Other Notes

Tombstoning - Tombstoning happens when the OS terminates the app process when the user navigates away from the app. The OS maintains the state of the app and if user navigates back to the app, the OS passes the state data to the app process
Persistent Data - is data that is shared by all instances of an app. For ex. app settings.
Transient Data - is data that describes the state of a single instance of the application. Its stored in the state dictionary. State dictionary is provided by Phone Application Service.
Application bar is a place where we can keep common buttons for our application

If you change the SupportedOrientations property in MainPage.xaml or any other page to “PortraitOrLandscape”, we can tilt the phone and the page will change automatically to landscape or portrait.

Overview

Frame: Only a single frame is available to the application. No exceptions.
Besides other things Frames host pages.
If you want an application bar for the entire application, you should put it in the frame.
If you want an application bar specific to the page, you should put it in the page.
System Tray: is a reserved area by the system to display system level details. It can be made visible/invisible by changing the SystemTray.IsVisible property in the page xaml file.
Orientation: Windows phone supports both portrait and landscape orientation. You can change the orientation by changing the SupportedOrientations and Orientation property in the page xaml file. If you change the SupportedOrientations property to "PortraitOrLandscape", when you tilt the phone, the page will change accordingly.

If you download the windows phone 7 developer tools, you can start creating windows phone 7 projects. It also comes with an emulator which gives you a visual feel for your application. In the next blog post, I will create a sample windows phone 7 application.

Extension Methods in LINQ

2011-01-02T02:16:00.001-05:00

In this blog, I will create a sample of a very useful feature provided by LINQ. These are called extensions and can be very handy to write helpful methods.
As the name suggests, extension methods allows us to extend the functionality of classes. This is very useful when we don't have the code for such classes.
Let's see an example. It's a very common scenario where we need to convert a string value to an integer. We can simply use the int.TryParse() to achieve this result but sometimes, the string value returned might be "12.0" and in such cases int.TryParse() will not be able to convert the string to integer and will throw an error. Let's say for the sake of this example, even if the string returns "12.4" we don't care about the decimal part and we want the result to be returned as integer. So in case of "12.4" the result should be 12 and in case of "12.6" the result should be 13 and in case the string is invalid as in "abc" the result should be 0. Out of the box this functionality is not provided. So we can write an extension method and use it in all other modules wherever this might be needed.
Let's take a look at the code:

public static class HelperExtensions
    {
        public static int ToIntWithRounding(this string input)
        {
            if (string.IsNullOrEmpty(input))
                return 0;

            if (string.IsNullOrWhiteSpace(input))
                return 0;

            double d = 0;
            if (double.TryParse(input, out d))
            {
                return (int)System.Math.Round(d, MidpointRounding.AwayFromZero);
            }
            else
                return 0;
        }
    }

Then somewhere I call this method as shown below:

var strings = new List<string>() { null, "     ", "12", "12.4", "12.6", "abc" };
            foreach (string s in strings)
                Console.WriteLine("\"" + s + "\"" + "\t\t" + s.ToIntWithRounding().ToString());

And here is the output:

Points to note:

The class in which this static extension method is declared should be static as well.
The extension method itself has to be static
The first argument of extension method should be a "this" object where "this" is the object on which you want the extension method to be available on. In our example, we did it on the string object.
Intellisense works with extension methods as shown in the picture below:

Stopwatch

2010-12-24T14:21:00.004-05:00

Many a times I had to measure the time a method, a module or a functionality is taking. The only way I knew till now was to do it the DateTime way. Now, there is a new class to help us out with that: Stopwatch
Earlier, I would have to get the current time before start, current time after finish, then use the TimeSpan class to subtract after and before times, to finally get the elapsed time. All this has been made a little easier by the introduction of Stopwatch class.
Stopwatch class is in System.Diagnostics namespace. Lets take a look at the code:

private static void StopwatchExample()
        {
            Stopwatch sp = new Stopwatch();
            sp.Start();
            LongRunningMethod1();
            sp.Stop();
            Console.WriteLine("Total time taken by LongRunningMethod1: " + sp.ElapsedMilliseconds);

            sp.Start();
            LongRunningMethod2();
            sp.Stop();
            Console.WriteLine("Total time taken by LongRunningMethod1 AND 2: " + sp.ElapsedMilliseconds);

            sp.Restart();
            LongRunningMethod3();
            sp.Stop();
            Console.WriteLine("Total time taken by ONLY LongRunningMethod3: " + sp.ElapsedMilliseconds);
        }

        private static void LongRunningMethod3()
        {
            Thread.Sleep(3000);
        }

        private static void LongRunningMethod2()
        {
            Thread.Sleep(2000);
        }

        private static void LongRunningMethod1()
        {
            Thread.Sleep(1000);
        }

And here is the output:

So, first up we create an instance of Stopwatch class. Then we call simple Start and Stop methods to use the stopwatch. The object has ElapsedMilliseconds and Elapsed properties to measure the elapsed time. You can "Start" or "Restart" the stopwatch anytime. "Start" means stopwatch will start from the same time it was stopped last time. "Restart" will reset the stopwatch to 0, and then start counting the time.

Helpful SQL Commands

2010-12-24T01:42:00.001-05:00

SQL server provides a rich set of commands to do operations other than the normal CRUD operations. In this blog, I will try to maintain a list of commands that are frequently used and required.

sp_helpdb - returns a table with list of databases, their sizes, owners, created date, status and their compatibility level. Compability level is used to determine how certain features in this version will work. Usually, compatibility level 100 means SQL server 2008, 90 means SQL server 2005 etc.
sp_helpdb <dbname> - If a database name is provided then besides the information given by sp_helpdb, this command also provides information about file allocations for the specified dbname. This table shows the name, filename, filegroup, its size, max size, growth and usage.
select * from sys.<items> - This is a very helpful command to get a lot of information about a lot of items. By running this command, you can get information about databases, tables, columns, views, filegroups, logins, database files etc.
select * from INFORMATION_SCHEMA.COLUMNS where TABLE_NAME = <tablename> - Information_schema provides a great way to get information about schemas. With this command you can find out all the information about all the columns in table tablename. Using Information_schema you can also find information about Tables, Columns, Views, Constraints etc.
Version information - select @@version will give you all the information about the version of the SQL Server where you ran this query. It will also tell you about the edition, bit (32/64) etc.

Simple PLINQ example

2010-12-23T05:00:00.004-05:00

I love LINQ. From the onset, I liked the idea of having a simple and similar way of accessing any kind of data, be it objects, be it SQL data or xml or any other structured form. MSDN says that PLINQ is a parallel implementation of LINQ to objects. In this blog, I am providing a simple sample about one of the operators for PLINQ.
Advantage of using PLINQ, as with any other multi-threading scenario, is performance. First up, lets see the code to achieve that performance gain -

private static void SimpleExample()
        {
            var people = new List<string>();
            Load(people);
            var namesStartingWithN = new List<string>();

            List<long> times = new List<long>();

            for (int i = 0; i < 10; i++)
            {
                System.Diagnostics.Stopwatch sp = new Stopwatch();
                sp.Start();
                namesStartingWithN = people
                    // run in parallel
                    .AsParallel()
                    .Where(p => p.StartsWith("N"))
                    .ToList();

                sp.Stop();
                long et = sp.ElapsedMilliseconds;
                times.Add(et);
                Console.WriteLine("Total Time: " + et);
            }

            Console.WriteLine();
            Console.WriteLine("Average: " + times.Average());
        }

        static void Load(List<string> people)
        {
            Random rand = new Random();
            for (int i = 0; i < 1000000; i++)
            {
                int r = rand.Next(1, 5);
                string name = string.Empty;
                switch (r)
                {
                    case 1:
                        name = "Michael" + i;
                        break;
                    case 2:
                        name = "Sachin" + i;
                        break;
                    case 3:
                        name = "Roger" + i;
                        break;
                    case 4:
                        name = "Nadal" + i;
                        break;
                    case 5:
                    default:
                        name = "Pete" + i;
                        break;
                }

                people.Add(name);
            }
        }

In the Load method, I just create a large number of string objects which represent different names. Then, in the SimpleExample method, my goal is to find all the names that start with "N". This can be done by a simple LINQ query. But if you observe the LINQ query, I have also added "AsParallel()" operator. This instructs the compiler to run it in parallel. The outer for loop (which runs 10 times) is just for calculating the average time it takes with and without "AsParallel()".
Without "AsParallel()"

With "AsParallel()"

The results might differ from one machine configuration to other, but, its pretty evident that, there is a good performance gain.
Sometimes, we need to get results in a particular order. In this example, it was not necessary however if you need to return results in order, you can call the "AsOrdered()" operator after the "AsParallel()" operator.
The other important aspect about "AsParallel()" is that we can not change all our existing/new queries to have "AsParallel()" to gain performance. The reason for this is, if used wrongly, there is a good chance of race condition. We should analyze the usage of "AsParallel()" accordingly. Code below is a good example of race condition -

private static void RaceCondition()
        {
            for (int i = 0; i < 10; i++)
            {
                int sum = 0;
                try
                {
                    Enumerable.Range(1, 100000)
                        // This statement causes race condition
                        .AsParallel()               
                        .Select(n =>
                        {
                            sum += n;
                            return sum;
                        })
                        .ToList();
                }
                catch (AggregateException ex)
                {
                    foreach (Exception e in ex.InnerExceptions)
                    {
                        Console.WriteLine(e.Message);
                    }
                }
                Console.WriteLine(sum);
            }
        }

Without "AsParallel()"

With "AsParallel()"

As you can see the sum which was correct when we didn't use "AsParallel()" is now incorrect and inconsistent.

Data WareHousing and Business Intelligence

2010-12-21T21:07:00.004-05:00

In this blog, I look at some of the theoretical concepts behind Data Warehousing and how Data Warehousing helps in achieving Business Intelligence.

Data Warehouse (DW)

Is a big store which stores ALL of your data.
By All data it means that it can have anything ranging from DBs to Excel sheets to Outlook servers storing emails.
DW and production DB are two different things. While production DB is ideally suited to support production apps, DW is suited for -

making reporting easier
combining that data across multiple systems
reducing production load as production environments are not responsible to produce outputs such as reports and BI
providing long term storage of data.

Production DBs are not created for this purpose. Usually they follow the model of on-line transaction processing (OLTP). They are designed to be worked on single records with optimized and normalized data. This means, that duplications have been removed. So getting all data for a record might involve lots of joins. Hence they are not suitable for reporting. The other problem is doing such operations on production DBs can slow the production system down.
How DW solves this problem?

DW uses a different mechanism than OLTP. It uses OLAP - online analytical processing. In OLAP, number of tables are reduced thus reducing the number of joins and increasing the simplicity to retrieve that data.
In DW we actually denormalize the data so that the structure is simple to work with. This results in duplication of data, however, in recent times the cost of data storage has gone down and that additional cost is worth more when it comes to the gains in reporting.

When we denormalize the tables, we use a concept of surrogate key. This is a primary key to this new table which doesn't really have a meaning.
Fact: Fact tables are used to mark some events with respect to time. Facts joins dimensions. Facts also answer the question of "how much". For example, Fact table will contain the answer to who did the transaction, what kind of transaction was done, where it was done and when it was done (Just the ids for this "w" questions). Fact table might also contain the amount ("how much") of that transaction.
Dimension:

Dimension contains the actual values of who, what, where and when of the event. They hold the values that describe the facts. For example, who might point to Customer table, where might point to Country table, what might point to some lookup table and when might point to some history table. There are various types of dimensions -

Static Data: This is the data that never changes. For example WeekDays. A Sunday will always be Sunday. Such type of data is usually called a type 0 dimension.
A type 1 dimension is that kind of data in which case history is not required to be saved. Its simply overwritten.
A type 2 dimension is that kind of data in which case history is required to be saved. In this case we usually add 2 columns to the dimension table which contain the information of "from date" and "thru date". Initially, thru date is null, indicating that this record is current. When a new update record is inserted, we change the thru date to some date for the old record. Now the thru date of the new record becomes null, indicating that this is the current record.
A type 4 dimension is that kind of data in which you want to keep the history and values separate.
There might be cases where within 1 table you might have few different columns that have different type dimensions.
Usually, developers should never decide the type dimension of a column. It should always be decided by business as they know the data better.

A conformed dimension is a table which consolidates primary keys. For example, if we have 3 different systems each assigning different key to the same item, we first consolidate these 3 keys in a conformed dimension table. This is also a case where surrogate keys become helpful.

Business Intelligence (BI)

Transforming all the data that is there in the data warehouse into something meaningful is business intelligence.
One main example is to aggregate the data to produce reports which requires writing tools which can sift through large amounts of data.
Another example would be to analyze the data by looking for patterns and trends.
We might also want to do data mining on our data to come up with analysis that might not be that obvious from the data itself. For example, a customer buying a tennis racket is 95% likely to buy tennis balls, however, he is only 2% likely to buy a tennis net.

Constructing a DW/BI solution

Constructing a DW/BI solution involves 4 steps. Also, in the braces you see some of the MS tools that help us in doing that-

Creating a DW
ETL - Extract - Transform - Load (SQL Service Integration Services SSIS)

In ETL, Extraction means extracting data from the data stores
Transformation means transforming the data (denormalization etc as mentioned above) to match the table design in DW
Load means loading the data in DW

Analytics - Aggregation - Trending - Correlations (SQL Server Analysis Services)
Reporting (SQL Server Reporting Services)

Certificates

2010-12-20T20:09:00.001-05:00

In this blog, I will examine the basics of cryptography and usability of IIS Certificates. I will also describe symmetric key cryptography, public-private key cryptography, digital signing and SSL.
Symmetric Key Cryptography

In symmetric key cryptography, PartyA generates a key and somehow shares the key with PartyB.
Now, all the communication between the two parties is encrypted using this key.
Since no one else knows the key, they can not decrypt the data.

Public-Private Key Pair Cryptography

PartyA generates a public-private key pair. PartyA never shares the private key with anyone. The public key is available to all.
Two kinds of communications can be done through this key pair-

PartyA sends a message to PartyB:

PartyA puts a signature on the message using the private key. Its almost impossible to create the same signature on the same message since no one else knows the private key.
PartyB has the knowledge of Public key. So, it does a computation of checksum on the incoming message and verifies the signature. This ensures that the message actually came from PartyA and it has not been tempered. This is explained below in "Digital Signing and Verification" below.

PartyB sends a message to PartyA:

PartyB encrypts the message using the public key. Nobody can decrypt it because no one knows the private key.
PartyA is able to decrypt it using its private key.

Self signed certificate = Name of the entity (PartyA) + public key + signed using private key. If it is signed by some Certificate Authority (CA) then that means that it is signed using the private key of CA.
In short certificate is a name bound to a key.

Digital Signing and Verification

Digital Signing

Take Data(D) and run a hash on it giving a hash result(HR).
Encrypt this HR using private key of the signer, resulting in HRe.
This HRe is called signature.
Signer also has a certificate(C) which contains the public key of the signer.
D + HRe + C = digitally signed data

Verification

Run Hash on Data(D) to get hash result HR.
Take the signature (HRe) and decrypt using public key of the signer, resulting in HR.
If the HR in above 2 steps is equal that proves that the message came from the signer and the data hasn't been tempered with.
Usually Data(D) is the certificate itself. This process guarantees that the certificate came from the right source.

Certificates

If you look at a website's certificates you can find out a lot of information. Such as -

Issued By (Certificate Authority)
Issued To
Valid From etc

In the details tab, you see a lot of fields and their values.
The orange fields, such as, version, issuer, public key etc are header fields and they are always there.
The green fields may or may not be there. These fields are called extensions.
Some of the extension fields are marked with exclamation mark - they mean that if you don't know how to process them - you should not use the certificate.
You can use certutil.exe - a command line utility to do some operations on the certificates. For example, "certutil -dump abc.cer" will display all the contents of the certificate on the console. You can download a website's certificate by using "copy to file" feature for the certificate.
Private keys are located usually inside ProgramData\Microsoft\Crypto\RSA. But this depends on OS, configuration and other details.
IE uses the MS Crypto API to store the certificates but FireFox has its own store. You can access that by going to Tools->Options->Advanced->Encryption tab and then View Certificates button.
Usually certificates are chained. You can identify the parent using "Issuer" and "Subject" fields. If the "Issuer" and "Subject" are one and the same, that means its a root level certificate. Usually a CA first issues a root certificate to itself. Then it uses this certificate to issue other certificates for other CAs.

Certificate Revocation List

When you try to access a website which uses a certificate, the browser gets the certificate from that website and sees the Serial Number in the certificate.
This serial number is then sent to a URL, which is usually the URL of CA. This URL is located in the "CRL Distribution Points" header value.
If you go to this URL, you can download the *.crl file which contains a list of all certificates that have been revoked.
If the serial number you received is in this list, then usually the browser lets you know that this certificate is not valid and what action you would like to take.
Usually, it is a good practice to not take any further action as the certificate can not be trusted anymore.
Since the revocation list can become really large, another method is sometimes used. Its a separate service (called OCSP) where you call the service and it only replies with Yes or No stating whether the certificate is good or not.

SSL Handshake

Browser issues secure session request (usually, https://something)
Server sends X.509 certificate containing server's public key.
Browser authenticates certificate against list of known CAs. If CA is unknown, browser can ask for user action to proceed.
Browser generates a random symmetric key and encrypts it using server's public key and sends to server.
Browser and server now both know the symmetric key and rest of session proceeds using this symmetric key.

So, How does it all add up?

CA signs a certificate with its private key and gives it to a website. The certificate now contains the public key amongst other information.
When a browser requests some transaction on the website, the browser inspects the certificate and using the logic mentioned above (public key and checksum) it finds out whether the certificate was issued by the trusted CA. So just for this purpose, the browser doesn't need to go to CA all the time.
The only thing that requires CA access by the browser is when it wants to validate whether the certificate has been revoked or not as mentioned above.
If all is good, it shows a green signal suggesting the validity of certificate. Otherwise, it displays a warning or a red signal suggesting that the certificate couldn't be validated and warns user for further action.
For future data transfers, SSL Handshake establishes a symmetric key known only to browser and server.

WCF RIA Services - Authentication/Authorization

2010-12-05T02:56:00.001-05:00

In this blog, I continue to research on the Authentication/Authorization piece of WCF RIA Services. If you haven't read the overview, I encourage you to do so in my previous blog post titled "WCF RIA Services Overview". For Authentication/Authorization read on...

AuthenticationDomainService

The framework provides an AuthenticationDomainService on the server side. AuthenticationDomainService derives from AuthenticationBase which derives from DomainService. It provides mechanisms for authentication, authorization and user profiles.
AuthenticationBase provides default implementations for Login, Logout, GetUser, UpdateUser functions.

User

A User class is also generated on the server side.
It derives from UserBase which has Name and collection of Roles.
UserBase also implements IPrincipal and IIdentity.
The architecture is designed in this way so that we can easily add our custom properties to this user class. This way both the authentication needs and our biz needs are met. Once built, these properties also propagate to the client side.
A corresponding User proxy is also created on the client side which also implements the IPrincipal and IIdentity.
On server side you can access the user by accessing ServiceContext.User property.
On client side you can do so by accessing WebContext.User property.

AuthenticationDomainContext

After building the solution, a corresponding AuthenticationDomainContext gets created.
It derives from AuthenticationDomainContextBase which derives from DomainContext.

AuthenticationService

We can use the functions provided by AuthenticationDomainContext but RIA provides one more level of abstraction in the form of AuthenticationService on the client side.
This class provides methods such as Login, Logout, LoadUser, SaveUser etc. It also provides properties to access the User and its properties such as IsBusy, IsLoggingIn etc.
WebAuthenticationService inherits from AuthenticationService.
Two more classes, FormsAuthentication and WindowsAuthentication inherit from WebAuthenticationService. These classes are concrete.
The WindowsAuthentication class does nothing more but to prohibit the Login and Logout methods due to the nature of authentication.

WebContext

The client also generates a WebContext class when built. This class can also pretty much do everything that the FormsAuthentication and WindowsAuthentication can do but it provides a better abstraction level. What this means is that it is a more generic way to do authentication.
The WebContext class can also be added to the application level storage namely ApplicationLifetimeObjects (in app.xaml), making it easy to be accessible from anywhere in the client app.
It also provides the access to the current user from anywhere in the client app.
Once the WebContext is setup, we can use its properties to bind in our XAMLs to effectively enable/disable functionalities based on authentication.

Transport Security

To expose a service over HTTPS, you just need to apply the RequiresSecureEndpoint=true inside the EnableClientAccess attribute on top of the domain service.
The generated domain context will now call a different constructor to use HTTPS.
If your website is HTTP and you are making service calls through HTTPS, you will need to update the clientaccesspolicy to allow for cross domain/scheme calls.

Authorization

You can use RequiresAuthentication and RequiresRole attributes on top of services or operation scopes to make them secure.
Once the solution is built, these attributes propagate to the client side as well.
We can also do custom authorization by creating custom authorization classes.

Custom Authentication

Most of the times in business application, the membership framework provided by ASP.NET would not be enough.
Moreover, the framework provided user, roles entities might not tie up with our business requirements. In that case, we need to use custom authentication.
To implement custom authentication, we need to override a few methods in the AuthenticationDomainService.
The methods to override are:

ValidateUser
GetAuthenticatedUser
UpdateUserCore

Once these methods are implemented, we are actually bypassing the system provided by ASP.NET membership and are using our own system.

In this blog, we examined the authentication/authorization framework provided by WCF RIA services. It can be used out-of-box and it can be customized as well. One of the great advantages of WCF RIA services is that client generation is taken care of by the RIA architecture. This means that validation, attributes, authentication, authorization and other things are all in sync with each other.

WCF RIA Services Overview

2010-12-05T01:41:00.000-05:00

WCF RIA Services makes it easy to concentrate on the data and business logic rather than worrying about creating multiple layers. Besides that it also simplifies querying, updating, validation and authentication among other features.

Design Pattern

WCF RIA service design pattern has three main aspects. These reside between the DAL and UI Views.

Data Model - After the DAL is set up, RIA creates entity and metadata on the server side and entity proxies and metadata on the client side. A metadata file is added on the server side allows us to add, besides other things, validation rules to the entities.
DomainService - on the server side. Provides a way to add CRUD and custom logic. RIA architecture defines a stateless server.
DomainContext - on the client side. Provides a way to add methods to load and invoke server side functionalities. RIA architecture defines a stateful structure. This is to enable data caching on the client side.
EntityContainer - on the client side. To hold the entities since client is stateful. EntityContainer enables the client side data caching.
Most of the client side stuff is added automatically when we add server side items and build the solution.

Steps to get up and running

Create simple Silverlight application and enable WCF RIA services
Add your DAL (through Entity Framework or LINQ to SQL etc)
Add DomainService on the server side.
Build the solution
Build adds a DomainContext and entity structure with metadata on the client side.
Use this DomainContext to create queries. Queries are of type EntityQuery.
The service is located at http://localhost:xxxx/services/<appname>-web-<domainservicename>.svc

Updating/Retrieving Data

To update data, use the DomainContext's SubmitChanges(), RejectChanges() methods.
To retrieve data, use the DomainContext's Load method to load queries.
Load method provides an important option called LoadBehavior which is explained further below.

Validation

For validation, it provides attributes such as Required, Range etc which can be put on data entities on the server side and they will propagate to the client side.

Query operations on the domain service

Queries in the Domain service follow some simple rules based on WCF, such as, they can return/take only primitive types. There can not be any overloads. These functions need to be public etc.
If needed, we can decorate these functions in domain service by Query attribute. It provides us options to further constrain the results. For ex.

IsComposable - if set to false, doesn't allow the client to put any more filtering on the client side. The query has to be used as it is and no further composition is possible.
ResultLimit - to limit the no. of instances that can be retrieved from the server.
HasSideEffects - to indicate that the query should be invoked via HTTP Post. HTTP Get is the default.

Asynchronous Loading

Calls from client are asynchronous so that the UI is not stuck. The callbacks can be implemented using various ways.
As soon as the client call is made, the function returns a LoadOperation object.
We can handle the callback by providing a LoadOperation.Completed event or providing a lambda expression/delegate inline.

Client Side Data Caching

Once some data is loaded on client side, its cached by the Domain Context to improve performance.
Since data is cached, RIA provides a way to handle scenarios where the data on server side has changed. This is done by the LoadBehavior enum of the Load method. It has 3 options -

KeepCurrent - objects in the client cache are kept as it is. This is default.
RefreshCurrent - objects in the client cache are replaced by the objects on the server side when load is called.
MergeIntoCurrent - only updates the objects that have not been modified since the last time the cache was loaded. So all the client side objects which were modified remain the same. All client side unmodified objects are refreshed from the server.

Iron Ruby DLR Sample

2010-12-05T01:28:00.006-05:00

Recently, I created a very simple Iron Ruby sample for understanding how it works and what is the concept of DLR (Dynamic Language Runtime). DLR is built on top of CLR (Common Language Runtime). In .NET you can create apps which use IronRuby dynamic code and run them with the help of DLR.

You will need to download IronRuby from http://ironruby.net/Download

In this sample, I just created a script.rb file which has some simple calls to one of the functions of my class. Then I created a console app. The code in my console app looks like this:

public class Program
    {
        static void Main(string[] args)
        {
            var worker = new CSharpWorker();

            var runtime = IronRuby.Ruby.CreateRuntime();
            var engine = runtime.GetEngine("Ruby");

            var scope = engine.CreateScope();
            scope.SetVariable("worker", worker);

            string fileName = @"C:\Demo\script.rb";
            var script = engine.CreateScriptSourceFromFile(fileName);
            script.Execute(scope);

            Console.ReadLine();
        }
    }

    public class CSharpWorker
    {
        public void SaySomething(string str)
        {
            Console.WriteLine(str);
        }
    }

This code creates a runtime with Ruby engine and sets the scope of the script file to worker object. Once the execute is called, the code in script.rb file gets called. Code in script.rb file is a simple line: worker.SaySomething("Hi There")
When the script file runs, it outputs "Hi There". We can now change the script.rb file without the need of building the console exe.
We can create complex classes in the script.rb file and execute the same using this simple technique.

HTTP

2010-09-15T12:18:00.000-04:00

In this blog, I will document some basic concepts about HTTP. HTTP stands for Hyper Text Transfer Protocol and is a way to communicate between a server and a client. I will also look into some of the Headers associated with HTTP.
HTTP belongs to the Application layer of internet protocol suite along with SMTP, DNS, Telnet etc. Each communication contains a request from the browser and a response from the server.
Request and Response usually have 3 parts. The first line is either a request line or a status line (in case of response). Second line contains the headers and the third line contains the body. Let's examine the first line.

Request Methods
HEAD - similar to GET but it only sends the headers without the response body.
GET - requests a static or a dynamic resource.
POST - to submit data to the server. The data to be submitted is put in the body of the request.
PUT and DELETE - to upload and delete specified resource
TRACE - server sends the received request so that client can see if intermediate servers made any modifications to the request.
OPTIONS - returns HTTP methods that are supported on the requested URL.
CONNECT - to facilitate HTTPS encrypted communication over an unencrypted HTTP proxy. In this mechanism, the client asks an HTTP Proxy server to forward the TCP connection to the desired destination using the "CONNECT" HTTP method. The server then proceeds to make the connection on behalf of the client. Once the connection has been established by the server, the Proxy server continues to proxy the TCP stream to and from the client. Note that only the initial connection request is HTTP - after that, the server simply proxies the established TCP connection. This mechanism is how a client behind an HTTP proxy can access websites using SSL (i.e. HTTPS).
PATCH - to facilitate partial modifications to a resource.
Let's now take a look at some of the more important request and response headers.

Request Headers
Accept - acceptable content types. Similarly Accept-charset, language, encoding means acceptable charsets, languages and encodings by the browser.
Content-type, Content-length and Content-MD5 - denotes type, length and base-64 encoded binary MD5 sum of the content of the request
Authorization - authentication credentials for HTTP authentication
Cache-control - to control caching.
Connection - preferable connection.
Cookie - an HTTP cookie sent previously by server with Set-Cookie header.
Max-forwards - max number of hops the message can be forwarded through proxies and gateways.
Host - domain name of the server.
Referer - address of the previous web page from which the currently requested page was followed.
User-agent - tells the browser from which request is coming.
Via - informs the server of proxies through which the request was sent.
Date - date and time when the request was sent.

Response Headers
Cache-control - to control caching.
Connection - options that are desired for this connection
Content-encoding, language, length, MD5, type - describes the metadata about the content.
Expires - date and time at which the response becomes stale.
Server - name of the server
Set-Cookie - sets the cookie which will be stored by the browser and will be sent back. The cookie can be used for authentication, setting user preference, identifying user session, contents of shopping cart etc.
Via - informs the client about the proxies through which the request was sent.
WWW-Authenticate - indicates the authentication scheme that should be used to access the requested entity. For ex, basic or digest.
There are some non-standard headers as well. Usually they start with an x-.

Response Status Codes
1xx - Informational. For ex.

122 - requested URI is too long (> 2083 chars)

2xx - Success

200 - OK
204 - No Content

3xx - Redirection

4xx - Client Error

400 - Bad Request
401 - Unauthorized
403 - forbidden
404 - not found

5xx - Server Error

500 - internal server error
503 - service unavailable
504 - gateway timeout

INotifyPropertyChanged and ObservableCollection

2010-08-13T20:07:00.016-04:00

In case of binding scenarios, earlier, developers had to write code to make sure that UI and internal objects are all in sync with each other. With INotifyPropertyChanged interface and ObservableCollection<T>, it has become simple to keep those layers in sync.

INotifyPropertyChanged

This interface can be implemented to notify to the client that some property has changed. Its mostly used in the case of databinding scenarios.
Its usage is demonstrated below:

public partial class A01NotifyPropertyChanged : Window
    {
        Person p;
        public A01NotifyPropertyChanged()
        {
            InitializeComponent();
            p = new Person { Age = 29 };
            DataContext = p;
        }

        private void changeItemBtn_Click(object sender, RoutedEventArgs e)
        {
            p.Age += 1;
        }
    }

    public class Person : INotifyPropertyChanged
    {
        private int m_age;
        public int Age 
        {
            get
            {
                return m_age;
            }
            set
            {
                if (value != m_age)
                {
                    m_age = value;
                    if (PropertyChanged != null)
                        PropertyChanged(this, new PropertyChangedEventArgs("Age"));
                }
            }
        }

        public event PropertyChangedEventHandler PropertyChanged;
    }

The corresponding XAML file looks like this:

<Grid>
        <StackPanel>
            <TextBox Text="{Binding Age}"/>
            <Button Content="Increase By 1" Name="changeItemBtn" Click="changeItemBtn_Click" />
        </StackPanel>
    </Grid>

In this code, every time the button is clicked, the age is increased by 1. However notice that we have not written any code to update the UI. Since the Person class implements the INotifyPropertyChanged event, the UI, which in this case is the textbox, automatically gets updated.

ObservableCollection<T>

Similar to INotifyPropertyChanged, there is another interface named INotifyCollectionChanged, which does the same thing but on collections.
However, instead of implementing INotifyCollectionChanged, we are already provided with ObservableCollection<T> which implements both INotifyCollectionChanged and INotifyPropertyChanged.
The purpose of this collection is to notify the client about additions, updates and deletes to the collection.
Its usage is demonstrated below:

ObservableCollection<string> tasks = new ObservableCollection<string>();
        public A04ObservableCollection()
        {
            InitializeComponent();
            lv.ItemsSource = tasks;
        }

        private void btn_Click(object sender, RoutedEventArgs e)
        {
            if(!string.IsNullOrEmpty(tb.Text.Trim()))
                tasks.Add(tb.Text);
        }

        private void btnRemove_Click(object sender, RoutedEventArgs e)
        {
            string selectedName = lv.SelectedItem as string;
            tasks.Remove(selectedName);
        }

The corresponding XAML file looks like this-

<Grid>
        <StackPanel>
            <Label Name="lbl" Content="To Do List:"/>
            <TextBox Name="tb" Margin="3"/>
            <ListView Name="lv" Margin="3"/>
            <Button Name="btn" Margin="3" Content="Add Task to List" Click="btn_Click"/>
            <Button Name="btnRemove" Margin="3" Content="Remove Selected Task" Click="btnRemove_Click"/>
        </StackPanel>
    </Grid>

In this example-

We have an ObservableCollection called tasks and all we have done to bind it to UI is to assign the ItemsSource property of listview to the ObservableCollection.
Everytime an item is added, changed or deleted, ObservableCollection notifies the consumer automatically. This ensures that the UI gets updated automatically.

Useful DOS/Powershell Commands

2010-08-02T02:14:00.000-04:00

In this blog, I wanted to document some of the nice DOS/powershell commands that I frequently use.

nslookup - query the domain name service (DNS) to get information about domain names and ip addresses. For ex. nslookup www.microsoft.com or nslookup xxx.xxx.xxx.xxx
tracert - tracks the path a packet of information will take from your computer to the destination. It also gives the timing information. For ex. tracert www.microsoft.com
pathping - similar to tracert but it also pings each hop and gets additional information about timing, packets lost percentage etc. For ex. pathping www.microsoft.com

Most of the commands in powershell are a combination of "verb-noun" components. Common verbs are Get, Set, Out, Start, Stop, Restart, Add. Common nouns are Help, Command, Service, Computer, Location, ChildItems. Some of the more useful commands are described below:

get-alias
all commands in powershell have aliases. For ex. dir or ls (from linux based systems) both point to the same alias get-childitems. get-alias gets the aliases for all the commands.
get-childitem
similar to dir or ls in linux
get-command
lists all the commands
get-command -verb "get"
lists all commands with the verb get in it
get-command -noun "service"
lists all commands with the noun service in it
get-help dir
displays help for dir command
get-help dir -examples
displays help for dir with examples
get-help dir -detailed
displays a more detailed help
get-help dir -full
displays the full help
get-command | where-object {$_.Name.Contains("Cult")}
This example demonstrates pipelining. The output of get-command is fed into where-object command. where-object loops through each of the objects provided by get-command. $_ represents the "this" object in the .net context. So, this command will list all the commands whose name contains the word "Cult" in it.
get-command -verb "write" | sort-object length
sorts the input of get-command based on its length.
dir | select-object name, lastwritetime
select-object selects just the name and lastwritetime attributes from the input. The input is provided by the dir command.
clear-host
same as cls in cmd.

Some Excel Formulas

2010-06-03T20:10:00.002-04:00

Most of the people who use computers, have in some way or form used excel. Its always handy to know few important excel formulas that can help us write 1-liner code that otherwise in normal programming languages like C, C++ or even C# would have taken 10 or more lines of code. In this blog post, I will keep a list of helpful excel formulas.

If

syntax: if(condition, true value, false value)

example: =if(A3>B3,"A3 is larger", "B3 is larger")

offset - returns a reference to a range which is offset from provided cell/range

syntax: offset(from cell/range, rows up/down, column left/right, num of rows, num of cols)

example: =SUM(OFFSET(C7,2,3,4,5))

In this example, we start from C7 and then go 2 rows down because it is positive. If it was negative, we would have gone up. Then we go 3 columns to the right because it is positive. If it was negative, we would have gone left. Now from this cell, we select 4 rows and 5 columns and that becomes our result range. Then, we call SUM on this range.

match - searches for a value in an array and returns the relative position

syntax: MATCH(value to search, array to search in, match type)

example: =MATCH(B13,OFFSET(C12,1,1,4,1),0)

In this example, match will search the value in cell B13 in the array range provided by offset function. Match type 0 means it will return the relative position of the first value that is equal to the value in cell B13. Match type -1 would mean that it will find the smallest value that is greater than or equal to value in B13. Match type 1 would mean that it will find the largest value that is less than or equal to the value in B13. 1 is default.

index -

syntax: index(range, row, col)

example:=INDEX(D18:G20,2,3)

In this example, the index function will return the value in row 2 and col 3 in the range D18:G20 i.e value in F19 cell.

vlookup -

syntax: vlookup(value in first col, range, col to return value from, boolean match)

example: =VLOOKUP(3,D22:G27,4,FALSE)

In this example, vlookup will search the cell with value 3 in the first column of range D22:G27. Then for that row, it will go to the 4th column and return the value. boolean match is to control the case whether an exact match for 3 is found or not. True means that if 3 is not found in the first col then return the next largest value which is less than 3. False means find the exact match = 3 in the first column.

Events

2010-04-14T22:20:00.002-04:00

As I mentioned in my delegates article, it took me quite a lot of time to understand the importance of delegates and events. For some time, I was confused as to when would I need events. I understood the button click events but was not able to come up with a concrete non-UI scenario in which I would like to use events. In this blog post, I will share a scenario which made it very easy for me to understand events. I hope this makes it simple for you too -

Let's say our scenario is that there is a Person class and the Person class has an age property and we want something to happen when the Person's age changes. To put the responsibility on the consumer class to call a function everytime the age changes would be an error-prone approach. So we don't want to take that route. Let's say that on top of that, we still want the consumer class to be able to define what that change action should be. So basically, we are saying that, Person class should define the event, however, the implementation would be taken care by the consumer class. How can we achieve this?

public class A02Events
    {
        public static void DoSomething()
        {
            Person p = new Person { Name = "Peter", Age = 20 };
            p.AgeChanged += new Action<int>(p_AgeChanged);

            p.Age = 30;
            System.Threading.Thread.Sleep(1000);
            p.Age = 31;
            System.Threading.Thread.Sleep(1000);
            p.Age = 32;
            System.Threading.Thread.Sleep(1000);
            p.Age = 33;
        
        }

        static void p_AgeChanged(int arg)
        {
            Console.WriteLine("Age changed to " + arg);
        }
    }

    public class Person
    {
        public string Name { get; set; }

        private int m_age;
        public int Age
        {
            get { return m_age; }
            set 
            {
                if (m_age != value)
                {
                    m_age = value;
                    if(AgeChanged !=null)
                        AgeChanged(value);
                }
            }
        }

        public event Action<int> AgeChanged;
    }

In this example -

In the Person class we declare an event. Its an Action<int> delegate, meaning that it will take int as input and will return void.
In the A02Events class, we say that for this event call the method p_AgeChanged, everytime age changes. This call is made in the setter for Age property inside Person class.
Then, just for demonstration purposes, Peter ages very fast, almost at the rate of 1 year/1 sec. Everytime, the age is changed p_AgeChanged event is fired.

The output looks like -

Action and Func Delegates

2010-04-13T20:46:00.003-04:00

Earlier in .NET, we had to declare our own delegates definitions. This was cumbersome and more importantly not very intuitive. It took me a lot of time to understand the concepts of delegates. The newer versions of .NET frameworks come up with two handy delegates that are very easy to use -

Action Delegate

This delegate allows us to encapsulate a method that is not going to return anything, i.e its return type is void.
The numerous overloads provided range from 0 to 16 and they are all generic, meaning they can all have different types based on your needs.
Since it covers till 16 input arguments, I feel that it is good enough to cover most of the cases. If your function needs more than 16 inputs, its probably a good time to refactor the function.

Func Delegate

The difference between this delegate and Action delegate is that Func allows for return types.
It also provides numerous overloads similar to Action delegate. The last type defined is considered to be the return type.
Similar to Action delegates, I think that this is good enough to cover most of the scenarios.

public class A03ActionAndFunc
    {
        internal static void Run()
        {
            Action<string, int> someMethod1;
            Action<string, int, double> someMethod2;
            Func<string, string> someMethod3;
            Func<string, int, string> someMethod4;

            // based on business logic, we can decide which actual method to call
            someMethod1 = Example1;
            someMethod2 = Example2;
            someMethod3 = Example3;
            someMethod4 = Example4;

            someMethod1("someMethod1", 5);
            someMethod2("someMethod2", 5, 5.6);

            Console.WriteLine(someMethod3("someMethod3"));
            Console.WriteLine(someMethod4("someMethod4", 5));
        }

        private static void Example1(string s, int i)
        {
            Console.WriteLine("Args: " + s + ", " + i);
        }

        private static void Example2(string s, int i, double d)
        {
            Console.WriteLine("Args: " + s + ", " + i + ", " + d);
        }

        private static string Example3(string s)
        {
            return s.ToUpper();
        }

        private static string Example4(string s, int i)
        {
            return s.ToUpper() + ", " + i;
        }
    }

In the above example -

The definition of someMethod3 suggests that it will take 1 input of type string and it will output type string.
The definition of someMethod4 suggests that it will take 2 inputs. One of type string and the other of type int. The output type will be string.

The output looks like:

ASP.NET Authentication

2010-01-05T02:38:00.004-05:00

Authentication: Who are you? Default: Windows
Authorization: What are you allowed to do? Default: Anonymous

Authorization

Represented via Authorization element in web.config
For IIS6

can have a combination of allow and deny entries
order of these entries matter as they are evaluated based on the order they are entered. The closest entry wins.
anonymous users are represented by ? and * represents all users
with the entries, you can also define verbs such as get and post to configure if the user is authorized to do gets and posts.

For IIS7 and forward

can have combination of add and remove entries. The add entries can have accessType defined as allow or deny.
order doesn't matter. The rule is that deny always takes precedence over allow.
Since order doesn't matter, we should remember to use <clear/> to clear all entries that might exist in top level config files.
IIS7 authorization will take care of not just managed resources such as aspx files but also the unmanaged resources in your app such as .pdf, .jpg etc. So it is better to use IIS7 authentication/authorization model than ASP.NETs authentication/authorization model

IPrincipal and IIdentity

Once a user is authenticated, you can access him by HttpContext.User property or by Page.User property. Both these properties expose the IPrincipal.
IPrincipal contains IIdentity and a function called IsInRole to identify whether the user belongs to a role or not.
IIdentity contains the Name of the user, his AuthenticationType and whether he IsAuthenticated or not.

FormsAuthentication

When not all your users can have windows accounts, windows authentication is not a good approach.
It is cookie-based. What that means is that once you are authenticated, further requests are done based on the cookie. All the details are managed by ASP.NET.
Cookies are secured by encryption using secret key.
Once the cookie reaches the server, an HTTPModule named FormsAuthenticationModule decrypts and validates the cookie into HttpContext.User. This module also turns the outgoing 401 request into 302 redirect to login page.
Once you authenticate the user by some database lookup for his username and password, you can call the FormsAuthentication.RedirectFromLoginPage method to redirect him to your default page in the application.
The method takes the username and a boolean value indicating whether to create a persistent cookie on the hard drive or not.
To log out, just call the FormsAuthentication.SignOut() method and then redirect them to the default page of your app. This will inturn, redirect them to login page and if they login correctly, it will go to the default page.
An attacker might extract the cookie from the web request and store it on his machine and then use it to mimic the real user. To avoid this, we should try to set the RequireSSL option to true in the forms element inside authentication element. This would mean that the whole request stream is on SSL and then the cookie can't be extracted.
You can also set the timeout option in the forms element inside authentication element. This will ensure that the cookie expires after a while.
It is better to user Roles instead of users.
Roles have to be set in code by the developer. You can do so in the Global.asax file by handling the AuthenticateRequest event. It is fired when the security module has established the identity of the user.
With the help of identity, you can find out which roles this user belongs to and then you can create a new GenericPrincipal with identity and roles.
You can then assign this GenericPrincipal to the Context.User property.
Once you set up the roles, you can use the Location element in the configuration element in web.config to identify the resource and what all roles it can have as shown below:

<location path="AdminsAndPlayersOnly.aspx">
   <system.web>
      <authorization>
        <allow roles="Players"/>
        <allow roles="Admin"/>
        <deny users="*"/>
      </authorization>
   </system.web>
</location>

ASP.NET Membership

Membership and role providers provide an inbuilt implementation of general login features such as usernames, passwords and roles database, password resetting, security question features etc. Its designed for rapid action development but does not provide strong authentication.
Membership is all about forms authentication.
Membership also provides out of box controls to login, logout, password recovery, reset password etc.
Membership and role use default providers but they can be customized to use different providers.
The login code can be overridden to do something different if you don't want the default behavior.