public interface IMyInterface
    {
        void PrintMessage(string message);
    }

You can then create two different classes that both implement the interface:

    public class ConcreteClassA : IMyInterface
    {
        public void PrintMessage(string message)
        {
            Console.WriteLine("My implementation here: " + message);
        }
    }

    class MyConcreteClassB : IMyInterface
    {
        public void PrintMessage(string message)
        {
            Console.WriteLine("My other implementation here: " + message);
        }
    }

This means that when I implement the code like this:

    class Program
    {
        static IMyInterface myInterface;
        static void Main(string[] args)
        {
            myInterface = new ConcreteClassA();
            myInterface.PrintMessage("hello");
            myInterface = new MyConcreteClassB();
            myInterface.PrintMessage("good day");
        }
    }

I dont create a dependency for class Program on either ConcreteClassA or MyConcreteClassB. If I make any subsequent changes to either of these classes then it doesnt affect class Program because it only deals with the interface. Its a great way to abstract your code, and its something I did not realise after reading up on it. Can an abstract class provide the same type of “abstraction”? Not really, and for a several reasons, the first being that you cannot create an instance of an abstract class and secondly you would have to expose the implementation details of the classes that inherit the abstract class.

Json(courses.Courses.Select(t => new { CourseTitle = t.CourseTitle, CourseCode = t.CourseCode, CourseId = t.Id }));

Pretty damn neat, considering that Courses is a EF4 entity and I dont have to go and change or adapt it to play nicely with the JSON serializer.

Extension methods essentially provide a developer with a mechanism to extend the base functionality of a particular class. So lets say you want ToString() for a class to return a date in a particular format, then you could write an extension method that transforms the ToString() representation of that object into the DateTime format you desire. Creating an extension method requires that you create a static class with a static method, like:

    static class Extensions
    {
        public static string ToString(this Concept concept, DateTime startDate)
        {
            return startDate.ToString("dddd MMMM yyyy");
        }
    }

Where concept is an arbitrary class I created. If I create an instance of Concept and call ToString() I get the overload:

            Concept concept = new Concept();
            Console.WriteLine(concept.ToString(new DateTime()));

The second reason why I will not use PHP is because there are better dynamic languages available, such as Python and Ruby.

The third reason I wont develop websites using PHP is because PHP devs seem to think that because the develop a site in PHP they are already building an SEO friendly website. What utter crap. There seems to be this aura around PHP that makes it look like you automatically get website awesomeness packed in. Lets not forget that the art of development on most platforms require the same disciplined processes. Whether you write unit tests for .NET or PHP – you still need to write unit tests. Whether you test websites written using PHP or ASP.NET you still have to test them in browsers – you dont get cross-browser compatibility out of the box.

The fourth reason I wont use PHP for development is because .NET offers programming features such as LINQ and Generics.

• Byte
• Char
• Int16
• UInt16
• Int32
• UInt32
• Long
• ULong
• Short
• UShort
• Decimal
• Double
• Float
• SByte
• Single
• Boolean
• Int64
• UInt64

I enjoyed doing it anyway, and I’m trying to do small projects at night to keep me motivated.

• Describe the difference between a Thread and a Process?
• What is a Windows Service and how does its lifecycle differ from a “standard” EXE?
• What is the maximum amount of memory any single process on Windows can address? Is this different than the maximum virtual memory for the system? How would this affect a system design?
• What is the difference between an EXE and a DLL?
• What is strong-typing versus weak-typing? Which is preferred? Why?
• Corillian’s product is a “Component Container.” Name at least 3 component containers that ship now with the Windows Server Family.
• What is a PID? How is it useful when troubleshooting a system?
• How many processes can listen on a single TCP/IP port?
• What is the GAC? What problem does it solve?

I don’t know all the answers unfortunately, and if you visit that link you will see a whole list more, which I don’t all know either. But I guess the upside is that now you can find it out and make sure you do.

	
	








			New Website Under Construction
		

		


	

And if I use this code to loop through the childnodes:

            HtmlDocument doc = new HtmlDocument();
            string s;
            StringBuilder builder = new StringBuilder();
            using (StreamReader reader = new StreamReader(@"C:\Documents and Settings\user\Desktop\fremus.net\index.htm"))
            {
                while ((s = reader.ReadLine()) != null)
                {
                    builder.AppendLine(s);
                }
            }
            doc.LoadHtml(builder.ToString());
            Console.WriteLine(doc.DocumentNode.ChildNodes.Count);
            foreach (HtmlNode node in doc.DocumentNode.ChildNodes)
            {
                Console.WriteLine(node.Name);
                foreach (HtmlNode childNode in node.ChildNodes)
                {
                    Console.WriteLine("\t\t" + childNode.Name);
                    foreach (HtmlNode grandChildNode in childNode.ChildNodes)
                    {
                        Console.WriteLine("\t\t\t" + grandChildNode.Name);
                    }
                }
            }

I get the following result in my command line window:

As you can see from the output the html node has a text node. The head node has a text node, and it has 9 childnodes including 5 #text nodes. The body node has a text node as well, and it has 7 childnodes, four being #text and the other three being div. So what is this #text node? If you read this article on the W3C site you will see that it states:

A common error in DOM processing is to expect an element node to contain text.

However, the text of an element node is stored in a text node.

On the same page it then gives an example using a title tag. If you do a Google on “html #text node“, you will see that the second result points to an article and if you read the bit on the nodes it seems that each #text node is a child. The #text nodes that appear in the body node seem to point to the text spaces after each div or each element inside the body node. If I change my code slightly:

                    Console.WriteLine("\t\t" + childNode.Name);
                    foreach (HtmlNode grandChildNode in childNode.ChildNodes)
                    {
                        Console.WriteLine("\t\t\t" + grandChildNode.Name);
                        Console.WriteLine("\t\t\t\t" + grandChildNode.HasChildNodes);
                    }

It tells me that the divs have child elements, but the #text nodes do not. Thus it seems for each ‘empty space’ inside a node there exists a #text node. If I amend the HTML from earlier like this:

	
	





Test

Then the footer div will have two text nodes, and the paragraph node will have a textnode. My issues yesterday had to do with the way IE rendered the HTML and that when I used HTMLAgility to parse it, the node counts weren’t the same. From the sample HTML I have given so far that difference is negligble, but I found that if I went to a site like this one and I saved the HTML from IE and Chrome into separate HTML files and I ran my code with that HTML, I got different node counts. Here are two screenshots that illustrate this:

The first screen is the html from the page saved from chrome and the second one is from ie. Notice the extra text nodes.