Ideally, thats when a developer should say goodbye to the application vowing never to see the code again. Coz, if  he does, he’d end up mighty disappointed. Future developers would have literally pillaged the application to  systematically eliminate any traces of the original design, the code would be littered with dirty bug fixes and so -called enhancements that don’t “enhance” anything. The customer doesn’t care because the application still works,  the managers don’t care because they meet their revenue targets and the timelines, and the developers never cared  in the first place.

Keeping that in mind, I listed down a few ways which might help save your application from meeting the same fate.

• Keep it Simple:  The oft repeated rule in software design is “Keep everything as simple as possible, but not  simpler”. If the design is too complex, then in all probability no developer would take the pains to go through it  and understand the whole thing. Many software engineers are guilty of trying to force fit their code to use a certain design pattern. Instead,look for the pattern which best fits your requirement

• Keep it Modular: Dividing your application into logically seperated projects makes it easier to identify the right  places to make the changes. Proper namespaces help too. For e.g. an assembly with the namespace  ABCApplication.HelperObjects.FileIOOperations leaves no space for doubt about what it does.

• Keep it Visual: Sure, you might find the 1000 page SMTD an interesting read, but not everyone else will. Remember a  bored developer would be the most likely to introduce a dirty fix in the code. So, to keep things interesting, go  for easy to understand graphics and images. MS Visio is a great tool to model your application, and it supports  automatic code generation as well (Enterprise Architect version). And after creating the model, dont leave it in a  random location that even you would forget in 2 weeks. My advice is to check it in the Source control along with  the code and add it to the Visual Studio Solution.

• Keep it Commented: Good commenting is the most potent weapon in your arsenal to guide/warn/ prohibit future  developers from making changes they shouldnt be doing. XML comments are a great way to maintain uniform commenting  standards across the application and can also be used to generate comment documentation automatically (using the  /doc switch while compiling) . A good way to convey how you intended the code to be used is to include a sample code block in the xml comments itself. Keep it mind though, that the comments are stripped out by the compiler, so  if you want comments to appear in the intellisense while using the assemblies, then the generated documentation  file must be packaged along with the assembly.

The DLR according to wikipedia is “an ongoing effort to bring a set of services that run on top of the Common Language Runtime (CLR) and provides language services for several different dynamic languages.” As the definition says, it is independent of the CLR and adds no new OpCodes to the IL. Languages like C# used the DLR to introduce dynamic typing while maintaining the existing mechanism of statically determining types.

The dynamic keyword is the C# construct introduced for this. In short – it tells the compiler that the call to this method is to be resolved at runtime and not to be bothered by throwing compiler errors. Lets see a simple example for the usage of the dynamic keyword. Suppose you have a book class which has four main properties – Author, Publisher, Price and Number Of Pages. However, each book may have a lot of other properties as well, which you wont know at design time. So the question arises, how to store the additional information? The first answer that would come to mind is storing them in a collection class and later retrieving it. The dynamic class provides you with a neat way of doing this shown in the code below :-

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56

class Program
    {
        static void Main(string[] args)
        {
            // The dynamic keyword bypasses any compile time checking for this object
            dynamic _daVinciCode = new Book("Sample Author", "SomePublisher", 250, 450);
 
            /*** EXTRA PROPERTIES - NOT PRESENT IN THE OBJECT***/
            _daVinciCode.BookStores = new string[] { "Landmark", "Oddyssey", "Crosswords" };
            _daVinciCode.CitiesAvailable = new string[] { "Delhi", "Bangalore", "Chennai" };
            _daVinciCode.ExtraVat = 45;
 
            /*** PRINTING OUT EXTRA PROPERTIES VALUE ***/
            Console.WriteLine(_daVinciCode.ExtraVat);
        }
 
    }
 
    /// <summary>
    /// This is our dynamic class. It defines 4 concrete properties
    /// and a dictionary class for storing any other property values
    /// as well. The abstract class DynamicObject is implemented
    /// </summary>
    public class Book:DynamicObject
    {
        //Our four defined properties
        public string Author { get; private set; }
        public string Publisher { get; private set; }
        public double Price { get; private set; }
        public int NumberOfPages { get; private set; }
 
        //Constructor - Parametrized
        public Book(string _author, string _publisher, double _price, int _numberOfPages)
        {
            this.Author = _author;
            this.Publisher = _publisher;
            this.Price = _price;
            this.NumberOfPages = _numberOfPages;
        }
 
        //This collection object stores all the extra properties
        public Dictionary<string, object> _extraProperties = new Dictionary<string, object>();
 
        //At runtime this method is called in order to bind the propertyname to a Getter
        public override bool TryGetMember(GetMemberBinder binder, out object result)
        {
            return _extraProperties.TryGetValue(binder.Name.ToLower(), out result);
        }
 
        //At runtime this method is called in order to bind the propertyname to a setter
        public override bool TrySetMember(SetMemberBinder binder, object value)
        {
            _extraProperties.Add(binder.Name.ToLower(), value);
            return true;
        }
    }

The Book class is a dynamic type and derives from the abstract class DynamicObject. This base class can help determine how binding should occur at runtime. In our example, the dictionary object stores all the additional properties of the book class. The two overriden methods TryGetMember and the TrySetMember are responsible for the binding of the new properties to the dictionary object. The first time a property on a dynamic type is encountered, the DLR binds the property and then caches its address. So any subsequent calls are faster.

More on the DLR in future posts.

To prove this point, I set out to find if there is a relation between the length of each post and the comments it receives. Though, the number of comments is not the best yardstick to measure the popularity of the post, it certainly is the most concrete one. The best place to try this out seemed to be my organization’s internal blogosphere, which had a lot of sample data (3500+ posts). Since its impossible to manually collect data for that many posts, I wrote a program to write it to a text file from where any correlation could be identified. Its a mixture of retrieving the data through HTML and RSS and parsing it. Though it should be compatible with any WordPress version, the comment counting function might need some tweaking to make it work on later versions. Once the code finishes executing, you would have a text file with the name of each post, the length and the number of comments. The data in this file can be imported into Excel for further manipulation.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67

using System;
using System.Xml;
using System.Net;
using System.IO;
using System.Text.RegularExpressions;
using System.Windows.Forms;
 
public class TestRSS
{
    StreamWriter _swObj = new StreamWriter("Results.txt", true);
    public const string _feedURL = "http://blog.ganeshzone.net";
 
    public static void Main()
    {
        new  TestRSS().RunTests();
    }
 
    public void RunTests()
    {
        for (int i = 1; ; i++) //This is an infinite loop only to be broken when there are no more posts
        {
            XmlDocument _xdoc = new XmlDocument(); //a New XmlDocument object
            //Lets load the XML from the url
            _xdoc.LoadXml(GetXmlData(_feedURL + (i>1?"?paged=" + i+"&":"?" )+"feed=rss2"));
            XmlNodeList _xList = _xdoc.GetElementsByTagName("item");
            if (_xList.Count == 0)
                break; //This means there are no more blog posts
            foreach (XmlNode _tempNode in _xList)
                //This method writes the name of post, length and the number of comments delimited by a colon
                //So we need to remove the colon in case of any being present/
                //Example Data: - ASP.NET Evolution WebForms v/s MVC: 6060:0
                WriteToFile(_tempNode.FirstChild.InnerText.Replace(":", "") + ": " + _tempNode.SelectSingleNode("description").NextSibling.InnerText.Length + ":" + GetComments(_tempNode.FirstChild.NextSibling.InnerText));
        }
    }
 
    public string GetXmlData(string _url)
    {
        //An ordinary retrieval of data from the url using the HttpWebRequest
        //This is a workaround for sites with badly formed RSS feeds due to script tags.
        //Once we get the data, we can load it into an XmlDocument class
        HttpWebRequest _blogReq = (HttpWebRequest)WebRequest.Create(_url);
        HttpWebResponse _blogResp = (HttpWebResponse)_blogReq.GetResponse();
        StreamReader _respStream = new StreamReader(_blogResp.GetResponseStream());
        //Replace Script tags
        return Regex.Replace(_respStream.ReadToEnd(), @"<script[^>]*?>[\s\S]*?<\/script>", "");
    }
 
    public int GetComments(string _url)
    {
        //Retrieving the Comments from the HTML and not the RSS feed. I wasnt able
        //to find a workaround for 10 comment limit in the RSS feed in wordpress 2.3,
        //Hence retriving the HTML and matching the comment divs. Keep in mind this wont work
        //for higher Wordpress versions. Just take the comment tag and substitute accordingly
        Match _match = Regex.Match(GetXmlData(_url), "<div class=\"mycomment\"[^>]*?>[\\s\\S]*?<\\/div>");
        int _counter=0;
        for (; _match.Success; _counter++)
            _match = _match.NextMatch();
        return _counter;
    }
 
    public void WriteToFile(string _tobeWritten)
    {
        //Just write it to the file
        _swObj.WriteLine(_tobeWritten);
        _swObj.Flush();
    }
}

First, we need to set up Visual studio  to use the Sons of Strike. A few simple steps mentioned below are needed to accomplish this:-

• Enable Unmanaged Debugging in the Project Properties

• Set the symbol server to  *C:\localcache*http://msdl.microsoft.com/download/symbols. The symbol server can be set by going to Tools -> Options-> Debugging. This step allows Visual studio to download the symbols needed for debugging from the Microsoft server.

• Set a breakpoint in the code and press F5 to start the program in debug mode. Once the application hits the breakpoint, load the SOS.dll using the command .load SOS in the Immediate Window.

Now we are ready to use the debugging extension. And SOS is also compatible with debugging tools like WinDbg in case you are comfortable with using that. Click here for a list of SOS commands.

Now, lets see the code that we would use for seeing how generics work. It consists of a Generic Type Customer which contains a list of the generic type and a public integer property.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

class Employee
    {
 
        public int EmployeeID;
        public static int age;
        public static string Name;
    }
 
    class Customer<T>
    {
        public int CustomerID;
        List<T> _innerList = new List<T>();
 
        public List<T> ListItems { get { return _innerList; } }
 
        public void AddItems(T _addObject)
        {
            _innerList.Add(_addObject);
        }
    }

The main method to call this code is below. We create the Customer class in three types – a string, an integer and a custom Employee type. Of these the string and Employee are reference types while integer is a primitive value type.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

static void Main(string[] args)
        {
            Customer<string> _cxStringObj = new Customer<string>();
            Customer<int> _cxIntObj = new Customer<int>();
            Customer<Employee> _cxEmpObj = new Customer<Employee>();
 
            _cxStringObj.CustomerID = 34;
            _cxStringObj.AddItems("Ganesh");
 
            _cxIntObj.CustomerID = 23;
            _cxIntObj.AddItems(43);
 
            _cxEmpObj.CustomerID = 34;
            _cxEmpObj.AddItems(new Employee());
        }

Every .NET class has two main data structures it uses to maintain type identity – the MethodTable and EEClass. Every object has a pointer to its MethodTable, and this methodtable contains a pointer to the EEClass. In .NET 1.1, the EE class was the strongest identifier of Type Identity of an object, however with .NET 2.0 and the implementation of Generics, Generic Types can share the same EEClass, and the MethodTable takes on the mantle of being the unique type identifier.

There are two main ways of implementing Generics which were proposed by the researchers who were working at Microsoft (This paper provides details of the implementation).

• Expansion: In this way, whenever the runtime encounters a generic type, the code could be generated on the fly for the type being called. For e.g. in our code, when the object Customer<string> was encountered, it could have expanded into the string representation of the object. When the type Customer<int> was encountered, a similar expansion can be done for it.

• Code sharing: In this approach only a single instantiation is done for the generic type, and it is reused for all the calls.

The method chosen in the end was a mixture of both these approaches. Generic types share as much code as possible They contain the same EEClass as mentioned before, but also have distinct MethodTables. Even though they have distinct MethodTables, code is shared between compatible types (all reference types).

Fire up the debugger and load the SOS.dll. To see the particular instances of the type on the heap give the Command DumpHeap -type . Once all the three objects have been created, lets see the result of this command.

!DumpHeap -type Customer
 Address       MT     Size
01ed35cc 002331d8       16
01ed3604 00233284       16
01ed3638 0023336c       16
total 3 objects
Statistics:
      MT    Count    TotalSize Class Name
0023336c        1           16 GenericsTry.Customer`1[[GenericsTry.Employee, GenericsTry]]
00233284        1           16 GenericsTry.Customer`1[[System.Int32, mscorlib]]
002331d8        1           16 GenericsTry.Customer`1[[System.String, mscorlib]]
Total 3 objects

As you can see from the MT column, all the three objects have different MethodTables. Lets see the MethodTables for each of the three type instantiations.

The command is DumpMT -MD . First the Employee type. Think of the MethodTable as an extension to a conventional vtable which simply contains the method pointers. The MethodTable’s vtable points to 7 slots, 4 of which are inherited from the parent Object class and three which are defined by the object itself. If you see the JIT status, there is a YES and NONE. The NONE means the method has never been called by the JIT Compiler and it points to a temporary stub. The first time the method is called, it is compiled on the fly and the temporary stub is replaced with the actual method pointer. To optimize performance, JIT defers execution and compilation till as late as possible.

!DumpMT -MD 0023336c
EEClass: 00231420
Module: 00232c5c
Name: GenericsTry.Customer`1[[GenericsTry.Employee, GenericsTry]]
mdToken: 02000004  (Projects\GenericsTry\GenericsTry\bin\Debug\GenericsTry.exe)
BaseSize: 0x10
ComponentSize: 0x0
Number of IFaces in IFaceMap: 0
Slots in VTable: 7
--------------------------------------
MethodDesc Table
   Entry MethodDesc      JIT Name
70766aa0   705e4a34   PreJIT System.Object.ToString()
70766ac0   705e4a3c   PreJIT System.Object.Equals(System.Object)
70766b30   705e4a6c   PreJIT System.Object.GetHashCode()
707d7550   705e4a90   PreJIT System.Object.Finalize()
0023c058   0023313c     NONE GenericsTry.Customer`1[[System.__Canon, mscorlib]].get_ListItems()
0023c060   00233148     NONE GenericsTry.Customer`1[[System.__Canon, mscorlib]].AddItems(System.__Canon)
0023c068   00233154      JIT GenericsTry.Customer`1[[System.__Canon, mscorlib]]..ctor()

Lets see the MethodTable for the integer type. As you can see the EEClass for the Integer and Employee types are not same, this is because they are not compatible types and hence no code sharing can take place

!DumpMT -MD 00233284
EEClass: 002314b4
Module: 00232c5c
Name: GenericsTry.Customer`1[[System.Int32, mscorlib]]
mdToken: 02000004  (\GenericsTry\GenericsTry\bin\Debug\GenericsTry.exe)
BaseSize: 0x10
ComponentSize: 0x0
Number of IFaces in IFaceMap: 0
Slots in VTable: 7
--------------------------------------
MethodDesc Table
   Entry MethodDesc      JIT Name
70766aa0   705e4a34   PreJIT System.Object.ToString()
70766ac0   705e4a3c   PreJIT System.Object.Equals(System.Object)
70766b30   705e4a6c   PreJIT System.Object.GetHashCode()
707d7550   705e4a90   PreJIT System.Object.Finalize()
0023c080   00233254     NONE GenericsTry.Customer`1[[System.Int32, mscorlib]].get_ListItems()
0023c088   00233260     NONE GenericsTry.Customer`1[[System.Int32, mscorlib]].AddItems(Int32)
0023c090   0023326c      JIT GenericsTry.Customer`1[[System.Int32, mscorlib]]..ctor()

The last one is the string type. This brings us to interesting conclusions. Compare the first MethodTable with the last one. Both are reference types and hence compatible with other. It can be observed that the string and Employee tables have the same EEClass 00231420. The integer type however has the EEClass 002314b4. There is no way for primitive value types to share code with each other since they differ in size. For e.g. If we created a bool type for Customer class, it would still have a different EEClass and MethodTables.

!DumpMT -MD 002331d8
EEClass: 00231420
Module: 00232c5c
Name: GenericsTry.Customer`1[[System.String, mscorlib]]
mdToken: 02000004  (\GenericsTry\GenericsTry\bin\Debug\GenericsTry.exe)
BaseSize: 0x10
ComponentSize: 0x0
Number of IFaces in IFaceMap: 0
Slots in VTable: 7
--------------------------------------
MethodDesc Table
   Entry MethodDesc      JIT Name
70766aa0   705e4a34   PreJIT System.Object.ToString()
70766ac0   705e4a3c   PreJIT System.Object.Equals(System.Object)
70766b30   705e4a6c   PreJIT System.Object.GetHashCode()
707d7550   705e4a90   PreJIT System.Object.Finalize()
0023c058   0023313c     NONE GenericsTry.Customer`1[[System.__Canon, mscorlib]].get_ListItems()
0023c060   00233148     NONE GenericsTry.Customer`1[[System.__Canon, mscorlib]].AddItems(System.__Canon)
0023c068   00233154      JIT GenericsTry.Customer`1[[System.__Canon, mscorlib]]..ctor()

One more thing of notice is the Method Descriptors for the first and third types. The AddItems method in Customer class has the same Method descriptor for both the string and Employee implementation. So even after a MethodTable is duplicated, both those entries still point to the same Method Description. Even the name has the type System.__Canon, which is dynamically replaced by the type on which the method is called. This is an illustration of the second approach of code sharing given by the researchers from Microsoft.

Once the code for AddItems method is called for the first time, it is JIT Compiled and assigned a code address. The Method Descriptor holds this code address which is assembly code and can be viewed by the SOS command !u.  Till the method is Jitted, there is junk value in this field on the MethodDescriptor.

!DumpMD 00233148
Method Name: GenericsTry.Customer`1[[System.__Canon, mscorlib]].AddItems(System.__Canon)
Class: 00231420
MethodTable: 0023316c
mdToken: 06000005
Module: 00232c5c
IsJitted: yes
CodeAddr: 00aa0298

Running the CodeAddress would give you a bunch of assembly code that is executed when the method is called.

!u 00aa0298
Normal JIT generated code
GenericsTry.Customer`1[[System.__Canon, mscorlib]].AddItems(System.__Canon)
Begin 00aa0298, size 42
>>> 00AA0298 55               push        ebp
00AA0299 8BEC             mov         ebp,esp
00AA029B 57               push        edi
00AA029C 56               push        esi
00AA029D 53               push        ebx
00AA029E 83EC34           sub         esp,34h
00AA02A1 33C0             xor         eax,eax
00AA02A3 8945F0           mov         dword ptr [ebp-10h],eax
00AA02A6 33C0             xor         eax,eax
00AA02A8 8945E4           mov         dword ptr [ebp-1Ch],eax
00AA02AB 894DC4           mov         dword ptr [ebp-3Ch],ecx
00AA02AE 8955C0           mov         dword ptr [ebp-40h],edx
00AA02B1 833D142E230000   cmp         dword ptr ds:[00232E14h],0
00AA02B8 7405             je          00AA02BF
00AA02BA E8BABC3571       call        71DFBF79 (JitHelp: CORINFO_HELP_DBG_IS_JUST_MY_CODE)
00AA02BF 90               nop
00AA02C0 8B45C4           mov         eax,dword ptr [ebp-3Ch]
00AA02C3 8B4804           mov         ecx,dword ptr [eax+4]
00AA02C6 8B55C0           mov         edx,dword ptr [ebp-40h]
00AA02C9 3909             cmp         dword ptr [ecx],ecx
00AA02CB E8E0F1D16F       call        707BF4B0 (System.Collections.Generic.List`1[[System.__Canon, mscorlib]].Add(System.__Canon), mdToken: 060019f1)
00AA02D0 90               nop
00AA02D1 90               nop
00AA02D2 8D65F4           lea         esp,[ebp-0Ch]
00AA02D5 5B               pop         ebx
00AA02D6 5E               pop         esi
00AA02D7 5F               pop         edi
00AA02D8 5D               pop         ebp
00AA02D9 C3               ret

In this post, we have looked at how the CLR treats Generics and how it takes care of performance implications of Generics code by sharing as much code as possible without having to needlessly box and unbox the types being passed to the Generic classes.

I implemented a basic Binary Tree in .NET for adding custom types. The Tree is generic and can be used to add any type objects. Also the object must implement the generic versions of IComparable and IEquitable for their types and object types. This leaves the search logic’s implementation to the type rather than the data structure. The complete solution can be downloaded here.

Lets see the declaration of the Binary Tree along with the private members.

class BinaryTree<T> where
    T:IComparable<T>,
    IEquatable<T>,
    IEquatable<object>,
    IComparable<object>
{
    BinaryTree<T> _parentNode;
    BinaryTree<T> _leftNode;
    BinaryTree<T> _rightNode;
    public T Value { get; set; }

Each BinaryTree object must be aware of its parent node and its left and right children, and the value it holds. Lets see the logic for adding the node. The adding logic is recursive. If it finds a null value, then the value is substituted. If not, then the node to be added is compared. If the value is lesser than the same method is called on the leftnode. This happens recursively till we get the node where the value is to be added.

public void AddNode(T _nodeTobeAdded)
{
    if (null==Value)
        //We found the value. Yay!!
        this.Value = _nodeTobeAdded;
    else
    {
        //Compare the node to be added. Here the
        //type's IComparable is called.
        if (_nodeTobeAdded.CompareTo(Value) < 0)
        {
            //Go down the left node. If the left node is null,
            //then create a new object, else return the existing object.
            _leftNode = null==_leftNode ?new BinaryTree<T>(this):_leftNode;
            _leftNode.AddNode(_nodeTobeAdded);
        }
        else
        {
            //Go Down the right node.
            _rightNode = null==_rightNode?new BinaryTree<T>(this):_rightNode;
            _rightNode.AddNode(_nodeTobeAdded);
        }
    }
}

The GetNode method follows a similar logic, with recursive searching of the tree till a match is found, if no match is found then a null value is returned. Note that only around half of the tree is searched, rather than all of the nodes, as would be the case with a linkedList. GetNode is implemented both for the type and an object. In both cases the Equals method’s implementation is called, giving the generic type the ability to decide on its own equality logic.

public T GetNode(T _nodeToBeGotten)
{
   if(_nodeToBeGotten.Equals(Value))
       return Value;
   else if(_nodeToBeGotten.CompareTo(Value)<0)
       return null==_leftNode? default(T): _leftNode.GetNode(_nodeToBeGotten);
   else
       return null==_rightNode?default(T): _rightNode.GetNode(_nodeToBeGotten);
}

public T GetNode(object o)
{
    if (Value.Equals(o))
        return Value;
    else if (Value.CompareTo(o)>0)
        return (null == _leftNode) ?
            default(T) : _leftNode.GetNode(o);
    else
        return null == _rightNode ?
            default(T) : _rightNode.GetNode(o);
}

Deleting is a bit tricky business. We have four scenarios here:-

1. Its a leaf node, i.e. both the left and right children are null. This is the simplest scenario. Simply set the node itself to null
2. The LeftNode is null but the right node is not, in this scenario – the node’s right node is set to the parent node’s right node, and the node is set to null.
3. The Right node is null but left node is not. It is handled similar to the previous scenario.
4. Both leftNode and rightNode is not null. In this scenarios we need to go down the leftnode, and iterate to its right most non empty node. This node is to be replaced with the node to be deleted. Just the value needs to be replaced and the right most node should be orphaned.

public void DeleteNode(object o)
{
    BinaryTree<T> _tempNode1 = this.GetTreeNode(o);
    DeleteNode(_tempNode1);
}

public void DeleteNode(T _nodeTobeDeleted)
{
    BinaryTree<T> _tempNode1 = this.GetTreeNode(_nodeTobeDeleted);
    DeleteNode(_tempNode1);
}

private void DeleteNode(BinaryTree<T> _tempNode1)
{
    BinaryTree<T> _tempNode2 = _tempNode1;
    if ((null == _tempNode1._leftNode) && (null == _tempNode1._rightNode))
        _tempNode1._parentNode = null;
    else if (null == _tempNode1._leftNode)
        _tempNode1._parentNode._rightNode = _tempNode1._rightNode;
    else if (null == _tempNode1._rightNode)
        _tempNode1._parentNode._leftNode = _tempNode1._leftNode;
    else
    {
        bool _goingRight = false;
        _tempNode1 = _tempNode1._leftNode;
        while (_tempNode1._rightNode != null)
        {
            _tempNode1 = _tempNode1._rightNode;
            _goingRight = true;
        }
        _tempNode2.Value = _tempNode1.Value;
        if (_goingRight) _tempNode1._parentNode._rightNode = null;
        else _tempNode1._parentNode._leftNode = null;
        _tempNode1 = null;
    }
}

//Private methods to get the nodes to be deleted
private BinaryTree<T> GetTreeNode(T _nodeToBeGotten)
{
    if (_nodeToBeGotten.Equals(Value))
        return this;
    else if (_nodeToBeGotten.CompareTo(Value) < 0)
        return null == _leftNode ? default(BinaryTree<T>) : _leftNode.GetTreeNode(_nodeToBeGotten);
    else
        return null == _rightNode ? default(BinaryTree<T>) : _rightNode.GetTreeNode(_nodeToBeGotten);
}

private BinaryTree<T> GetTreeNode(object o)
{
    if (Value.Equals(o))
        return this;
    else if (Value.CompareTo(o) > 0)
        return (null == _leftNode) ?
            default(BinaryTree<T>) : _leftNode.GetTreeNode(o);
    else
        return null == _rightNode ?
            default(BinaryTree<T>) : _rightNode.GetTreeNode(o);
}

The class which could be added to the tree needs to implement the four interfaces i mentioned. I implemented an Employee class which has just two fields Name and age and the comparison is done based on the age.

class Employee : IComparable<Employee>,IEquatable<Employee>,IEquatable<object>,IComparable<object>
    {
        private string _name;
        private int _age;

        public int Age{get{return _age;}}

        public Employee(string _name, int _age)
        {
            this._name = _name;
            this._age = _age;
        }

        #region IComparable<Employee> Members

        public int CompareTo(Employee other)
        {
            if (this._age < other._age)
                return -1;
            else
                return 1;
        }

        #endregion

        public bool Equals(Employee other)
        {
            if (this._age == other._age)
                return true;
            else
                return false;
        }

        #region IEquatable<object> Members

        public override bool Equals(object other)
        {
            int _age=0;
            if (int.TryParse(other.ToString(), out _age))
            {
                return this._age == _age ? true : false;
            }
            else return false;
        }

        #endregion

        #region IComparable<object> Members

        public int CompareTo(object other)
        {
            int _age = 0;
            if (int.TryParse(other.ToString(), out _age))
                return this._age < _age ? -1 : 1;
            else return 1;
        }

        #endregion

    }

This is the main method which adds a few objects to the tree collection.

static void Main(string[] args)
{
    BinaryTree<Employee> _btree = new BinaryTree<Employee>(new Employee("RootValue",40));
    _btree.AddNode(new Employee("Test1", 34));
    _btree.AddNode(new Employee("Test2", 26));
    _btree.AddNode(new Employee("Test3", 65));
}

Here is the code for the game as a silverlight application. The complete project can be downloaded here.

The XAML is quite simple. Just a grid with three rows and three columns

    <grid x:Name="gridGame" Background="White" Width="300" Height="300" HorizontalAlignment="Center" VerticalAlignment="Center">
        </grid><grid .RowDefinitions>
            <rowdefinition Height="100" />
            <rowdefinition Height="100" />
            <rowdefinition Height="100" />
        </grid>
        <grid .ColumnDefinitions>
            <columndefinition Width="100" />
            <columndefinition Width="100" />
            <columndefinition Width="100" />
        </grid>

It is then filled with the buttons in the Code Behind. I have hardcoded the grid size of three but this will work with any size.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

 public MainPage()
        {
            InitializeComponent();
            InitializeGameLogic(true);
        }
 
        private void InitializeGameLogic(bool _fromConstructor)
        {
            if (!_fromConstructor)
            {
                gridGame.Children.Clear();
            }
            _logic = new TicTacLogic();
            for (int i = 0; i < 3; i++)
                for (int j = 0; j < 3; j++)
                {
                    Button _btnGrid = new Button();
                    _btnGrid.Name = "btn" + i.ToString() + j.ToString();
                    gridGame.Children.Add(_btnGrid);
                    Grid.SetRow(_btnGrid, j);
                    Grid.SetColumn(_btnGrid, i);
                    _btnGrid.Height = 80;
                    _btnGrid.Width = 80;
                    _btnGrid.Click += new RoutedEventHandler(_btnGrid_Click);
                }
            _logic.StartGame();
        }

All the dynamically generated buttons have a single event handler. The idea is to identify the button which sent the event from the name. Once we have the position of the button, the content has to be changed with an X. After the user marks, the computer does its stuff and makes its move. After every marking, a check is done if someone has won or the board is full.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

void _btnGrid_Click(object sender, RoutedEventArgs e)
        {
            Button _userClicked = sender as Button;
            int _xPos = Convert.ToInt32(_userClicked.Name.Substring(3,1));
            int _yPos = Convert.ToInt32(_userClicked.Name.Substring(4,1));
            _userClicked.Content = GetMarking("X");
            _logic.ClickUser(_xPos, _yPos);
            if (!(_logic.CheckIfSomeoneWon() || _logic.CheckIfBoardFull()))
            {
                int _xCom = 0;
                int _yCom = 0;
                _logic.MoveComputer(ref _xCom, ref _yCom);
                foreach (UIElement _tempElem in gridGame.Children)
                {
                    Button _comBtn = _tempElem as Button;
                    if (_comBtn != null && _comBtn.Name == "btn" + _xCom + _yCom)
                    {
                        _comBtn.Content = GetMarking("O");
                        break;
                    }
                }
                if (_logic.CheckIfSomeoneWon() || _logic.CheckIfBoardFull())
                    InitializeGameLogic(false);
            }
            else
                InitializeGameLogic(false);
 
        }
 
        private TextBlock GetMarking(string _mark)
        {
            TextBlock _t = new TextBlock();
            _t.Text = _mark;
            _t.FontSize = 25;
            _t.FontWeight = FontWeights.Bold;
            return _t;
        }

The Board class maintains two important things. The position of all the squares and which player has it marked. The Board doesnt depend on the Player objects. It has an object of the WinningPositions object which calculates the winning positions which can be compared with later. This object makes it possible to play with larger grids.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88

public class Board
{
    readonly int MAXSIZE;
    List<positionmarking> _boardState = new List</positionmarking><positionmarking>();
    List<position []> _allWinningPositions;
 
    public List<positionmarking> BoardState { get { return _boardState; } }
    public List<position []> AllWinningPositions { get { return _allWinningPositions; } }
    public int MaxSize { get { return MAXSIZE; } }
 
    public Board()
    {
        this.MAXSIZE = 3;
        Initialize();
    }
 
    public Board(int _maxSize)
    {
        MAXSIZE = _maxSize;
        Initialize();
    }
 
    private void Initialize()
    {
        _allWinningPositions = (new WinningPositions(MAXSIZE)).AllWinningPositions;
        for(int _xPos=0;_xPos<maxsize ;_xPos++)
            for (int _yPos = 0; _yPos < MAXSIZE; _yPos++)
            {
                _boardState.Add(new PositionMarking(_xPos,_yPos));
            }
    }
 
    internal void MarkPosition(int _xUser, int _yUser, bool _userMarked)
    {
        foreach (PositionMarking _tempPos in _boardState)
        {
            if (_tempPos.BoardPosition.X == _xUser && _tempPos.BoardPosition.Y == _yUser)
            {
                _tempPos.MarkPosition(_userMarked);
                break;
            }
        }
#if DEBUG
        PrintBoardState();
#endif
    }
 
    internal bool? MarkedByUser(Position _tempPos)
    {
        foreach (PositionMarking _tempMark in _boardState)
        {
            if (_tempPos.X == _tempMark.BoardPosition.X && _tempPos.Y == _tempMark.BoardPosition.Y)
                return _tempMark.IsUserMarked;
 
        }
        throw new Exception("Position Not found on Board");
    }
 
    #if DEBUG
    internal void PrintBoardState()
    {
        string _userMarked = "";
        string _compMarked = "";
        foreach (PositionMarking _tempMark in _boardState)
        {
 
            if (_tempMark.IsUserMarked == true)
                _userMarked += "("+ _tempMark.BoardPosition.X + "," + _tempMark.BoardPosition.Y + ") ";
            else if (_tempMark.IsUserMarked == false)
                _compMarked += "(" + _tempMark.BoardPosition.X + "," + _tempMark.BoardPosition.Y + ") ";
        }
        Debug.WriteLine("USER: " + _userMarked);
        Debug.WriteLine("COMP: " + _compMarked);
        Debug.WriteLine("________________________________________");
    }
#endif
    internal bool IsBoardFull()
    {
        foreach (PositionMarking _tempMark in _boardState)
        {
            if (_tempMark.IsUserMarked == null)
                return false;
 
        }
        MessageBox.Show("Board Full");
        return true;
    }
}

The Winning Position class is given below and all positions are calculated at initialization. First the horizontal ones are considered and then the vertical ones. The remaining diagonal positons are taken care later. Each winning position is stored in an array of the position object which just holds the value of the Squares. These arrays are stored in a generic List.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54

public class WinningPositions
{
    List<position []> _allWinningPositions = new List</position><position []>();
    Position[] _winPos1;
    Position[] _winPos2;
 
    public List</position><position []> AllWinningPositions
    {
        get { return _allWinningPositions; }
    }
 
    public WinningPositions(int _maxSize)
    {
        _winPos1 = new Position[_maxSize];
        _winPos2 = new Position[_maxSize];
        PopulateWinningPositions();
    }
 
    private void PopulateWinningPositions()
    {
        int _iCounter=0;
        int _xPos = 0;
        int _yPos = 0;
        for (_xPos = 0; _xPos < _winPos2.Length; _xPos++)
        {
            for (_yPos = 0; _yPos < _winPos2.Length; _yPos++)
            {
                _winPos1[_iCounter] = new Position(_xPos, _yPos);
                _winPos2[_iCounter] = new Position(_yPos, _xPos);
                _iCounter++;
            }
            _allWinningPositions.Add(_winPos1);
            _allWinningPositions.Add(_winPos2);
            _winPos1 = new Position[_winPos1.Length];
            _winPos2 = new Position[_winPos2.Length];
            _iCounter = 0;
        }
        _iCounter = 0;
        for (_xPos = 0, _yPos = 0;_xPos < _winPos1.Length; _xPos++, _yPos++)
        {
            _winPos1[_iCounter] = new Position(_xPos, _yPos);
 
            _iCounter++;
        }
        _allWinningPositions.Add(_winPos1);
        _iCounter = 0;
        for (_xPos = 0, _yPos = _winPos1.Length - 1; _xPos < _winPos1.Length; _xPos++, _yPos--)
        {
            _winPos2[_iCounter] = new Position(_xPos, _yPos);
            _iCounter++;
        }
        _allWinningPositions.Add(_winPos2);
    }
}

Then there is the Player class of which we create two objects. The user takes care of his own moving logic, all we need to do is to change the state of the square for him. But the computer has its method called the SmartMove. Here we first move through the winning positions to identify any open squares that can be marked. If there are no squares, then we look to block the opponent's winning. If even this opportunity is not found, we mark an available open square.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83

public class Player
{
    Board _currentBoardPosition;
    bool _isComputer;
    List<position> _allMarkedPositions;
 
    public Player(bool _isComputer,Board _currentBoardPos)
    {
        this._isComputer = _isComputer;
        _allMarkedPositions = new List</position><position>();
        _currentBoardPosition = _currentBoardPos;
    }
 
    internal void SmartMove(ref int _xCom, ref int _yCom)
    {
        bool _markingDone = false;
        bool _blockUser = false;
        Position _userBlock = new Position();
        foreach (Position[] _winPos in _currentBoardPosition.AllWinningPositions)
        {
            int _userMarked = 0;
            int _computerMarked = 0;
            int _nullMarked=0;
 
            Position _openPos= new Position();
            foreach (Position _tempPos in _winPos)
            {
                bool? isUserMarked = _currentBoardPosition.MarkedByUser(_tempPos);
                if (isUserMarked==true)
                    _userMarked++;
                else if (isUserMarked == false)
                    _computerMarked++;
                else
                {
                    _openPos = _tempPos;
                    _nullMarked++;
                }
 
            }
            if (_computerMarked == 2 && _nullMarked == 1)
            {
                Debug.WriteLine("Wining block: " + _openPos.X + "," + _openPos.Y);
                _currentBoardPosition.MarkPosition(_openPos.X, _openPos.Y, false);
                _xCom = _openPos.X;
                _yCom = _openPos.Y;
                _markingDone = true;
                break;
            }
            else if (_userMarked == 2 && _nullMarked == 1)
            {
                _userBlock = _openPos;
                _blockUser = true;
            }
 
        }
        if (_blockUser && !_markingDone)
        {
            _currentBoardPosition.MarkPosition(_userBlock.X, _userBlock.Y, false);
            _xCom = _userBlock.X;
            _yCom = _userBlock.Y;
            _markingDone = true;
        }
 
        if (!_markingDone)
        {
 
            //No Winning Position Found or not able to block;
            foreach (PositionMarking _posMark in _currentBoardPosition.BoardState)
            {
                if (_posMark.IsUserMarked == null)
                {
                    _markingDone = true;
                    _currentBoardPosition.MarkPosition(_posMark.BoardPosition.X, _posMark.BoardPosition.Y,false);
                    _xCom = _posMark.BoardPosition.X;
                    _yCom = _posMark.BoardPosition.Y;
                    break;
                }
            }
 
        }
    }
}
</position>

Since the Board needs to maintain the state of each and every position on itself, we have another object for it, which maintains a position object and a nullable boolean. If the boolean is true, then the square is marked by the user, if false - then by the computer. If its still null - its open and can be marked. The marking is done by the object's method which makes a check to make sure no players marking is overwritten by another.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

public class PositionMarking
{
    Position _boardPos;
    bool? _isUserMarked;
 
    public Position BoardPosition { get { return _boardPos; } }
    public bool? IsUserMarked { get { return _isUserMarked; } }
 
    public PositionMarking(int _xPos,int _yPos)
    {
        _isUserMarked = null;
        _boardPos = new Position(_xPos, _yPos);
    }
 
    public void MarkPosition(bool _markedByUser)
    {
        if(_isUserMarked == null)
        _isUserMarked = _markedByUser;
        else
        throw new Exception("Position already taken");
    }
}

Then there is the rest of the code including our business logic layer.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93

public class TicTacLogic
{
    bool _userToMove;
    bool _resultHasCome;
    Player _user;
    Player _computer;
    Board _gameBoard;
 
    public TicTacLogic()
    {
        _userToMove = true;
        _resultHasCome = false;
    }
 
    internal void StartGame()
    {
        Initialize();
    }
 
    internal bool ClickUser(int _xUser, int _yUser)
    {
        return _gameBoard.MarkPosition(_xUser, _yUser, true);
    }
 
    internal void MoveComputer(ref int _xCom, ref int _yCom)
    {
        _computer.SmartMove(ref _xCom, ref _yCom);
    }
 
    internal void Initialize()
    {
        _gameBoard = new Board(3);
        _user = new Player(false,_gameBoard);
        _computer = new Player(true,_gameBoard);
 
    }
 
    public bool CheckIfSomeoneWon()
    {
        foreach (Position[] _tempWin in _gameBoard.AllWinningPositions)
        {
            int _userWon=0;
            int _compWon=0;
            foreach (Position _p in _tempWin)
            {
                bool? isUserMarked = _gameBoard.MarkedByUser(_p);
                if (isUserMarked == null)
                    break;
                else if (isUserMarked == true)
                    _userWon++;
                else
                    _compWon++;
 
            }
            if (_userWon == _gameBoard.MaxSize)
            {
                MessageBox.Show("User Won");
                return true;
            }
            else if (_compWon == _gameBoard.MaxSize)
            {
                MessageBox.Show("Computer Won");
                return true;
            }
 
        }
        return false;
    }
 
    internal bool CheckIfBoardFull()
    {
        return _gameBoard.IsBoardFull();
    }
}
 
public class Position
{
    int _xPos;
    int _yPos;
 
    public Position()
    {
    }
 
    public int X { get { return _xPos; } }
    public int Y { get { return _yPos; } }
 
    public Position(int xPos, int yPos)
    {
        this._xPos = xPos;
        this._yPos = yPos;
    }
}

]]> http://blog.ganeshzone.net/blog/index.php/2010/01/tic-tac-toe-game-in-silverlight/feed/ 0 http://blog.ganeshzone.net/blog/index.php/2010/01/deploying-asp-net-mvc-apps-on-shared-hosting/ http://blog.ganeshzone.net/blog/index.php/2010/01/deploying-asp-net-mvc-apps-on-shared-hosting/#comments Sun, 10 Jan 2010 18:20:39 +0000 Ganesh Ranganathan http://blog.ganeshzone.net/blog/?p=823 Here are the steps to deploy MVC applications to servers with shared hosting providers.

MVC seeks to give developers an alternative, where they have complete control over the application including the viewstate of the controls. My first look was at ASP.NET MVC was a training session given by an architect from Microsoft, and I absolutely didn’t like the complexity it brought to a simple demo application that was showed. I found that we were writing too much code, again bringing back spaghetti code that died with ASP. But over time, after digging into MVC, I found that it made a lot of sense. If my need is just to display a set of data, why should I sacrifice performance over all of the gridview’s bulky viewstate. Rather, it makes sense to use a HTML table and apply CSS to style it.  That is exactly the flexibility that MVC gives you, instead of relying on built in abstraction done by Webform architecture, you get to control every detail of your application.

WebForms

ASP.NET Webforms are radically different from any other server side scripting technology. For one, its event driven. Just like Windows programming, you assign an event handler to an element, like a button and it calls the handler when the button is clicked. No longer, do you have to keep on submitting the form to handle click events and write bulky code to do simple stuff. ASP.NET made the server side code clean – in fact a helluva lot cleaner than ASP.

But all this ignores the age old truth about the web/HTTP – that it is stateless. The server forgets about the page the minute its sent to the client and thats the end of it. So how is context maintained in WebForms? The answer is Viewstate. All of the control states are Base64 encoded and recreated on the server again where the request is executed. There is a lot of built-in plumbing to achieve this level of abstraction.

The main problem with webforms is that though it cleans up your code and markup and seperates them neatly in your Visual studio solution, it horribly clutters the rendered markup to the browser. Every control takes up more and more viewstate and the nested control names which are really long, make the markup bulky, and since this does a round trip on every request, it starts impacting performance and eventually scalability.

One more concern is the Testability, due to the event driven approach, the GUI is tighly coupled with your business layer and there isnt any effective way to test your web page. Automating such testing could be an tedious effort and you would most probably end up doing manual testing.

Despite all of these problems, Webforms are not a bad architecture. It is extremely mature and extensible. A lot of good documentation exists for it and it still makes sense for quite a few scenarios.

MVC

With MVC, it was love at first byte. In fact I never realized how inefficient webforms were, until i worked with MVC. Instead of a page receiving the request, its the Controller which lives at the heart of MVC. Once it gets the request, it decides which view to render and may use models.

One great thing about MVC is the clean Seperation of Concerns (SoC ) which you are able to achieve out of the box. Both the Controllers and the Views can be tested separately using testing tools like NUnit or MBUnit. So that means no longer. Manual testing doesn’t really make any sense for most scenarios, because the effort is not repeatable and when you want to try with a different input, you would need to start all over again.

One major point that is oft repeated is that we shouldn’t jump the gun to convert every existing webforms applications into MVC just because its the in thing. You would have to rewrite your application completely, and the benefit derived would often not be worth the effort. But I would certainly  recommend that  you use MVC for any new applications you create. Its certainly the smarter way.

]]> http://blog.ganeshzone.net/blog/index.php/2010/01/asp-net-evolution-webforms-vs-mvc/feed/ 3