String.Format is a very powerful method but the documentation at MSDN is quite wordy and spreads the details over many pages. For this post I have made quick reference to its many specifiers and for good measure added some examples to help get you started.If you would like to format a date, currency, number or just the time, String.Format is your friend.

For a trip down memory lane a little example how we did things in C. The C sprintf function takes a buffer, a formatting string, a couple of parameters and munches them together:

#include <stdio.h>
int main()
{
char buffer[255];
sprintf(buffer,"Customer %d lives is %d years old and owns us %2.2f dollars", 1024, 96, 125.6f);
printf("%s",buffer);
}

This results in the following output:

Customer 1024 is 96 years old and owns us 125.50

Of course, if we made the buffer too small and the string expanded too much we might have created a buffer overrun once of C’s pesky little annoyances. And of course for each parameter we need to specify how to format them (%d for integers, %s for strings and %f for floats). Get the type wrong and things will go funny fast.

Enter String.Format and Console.WriteLine

So how do things work in C#? The String.Format method takes care of all our needs and a little more. Similar to the relationships between sprintf and printf the methods String.Format and Console.WriteLine work similary. String.Format returns a string whereas Console.WriteLine sends the resulting string to the console output.

The following should be a familiar example:

int ResultValue = 123;
string myString = String.Format(”The value is {0}”,ResultValue);
Console.WriteLine(”The value is {0}”,ResultValue);

The Index

The {0} is an index and refers to the first parameter given following the formatting string. {1},{2} to the second, third etc. You can also refer to a parameter more than once. The following is perfectly acceptable:

Console.WriteLine(”First {0}, Second {1}, Third {2}, And again the First {0}”,Value1,Value2,Value2);

Aligning the output

C# provides an alignment value that allows you to left or right align the output. Handy for screen or print formatting.

If you specify an alignment of 10 characters the resulting string will always be 10 characters even if the number only took up 4 places. The remainder is padded with spaces. If the value we want to display is longer than our given alignment size the alignment value is ignored.

Console.WriteLine(”The value is {0,10} – continue from here”,9999);

The above will output the value “9999″, and allocate 10 spaces for it. The output is right-aligned, the format method will simply add sufficient spaces to make sure the total length adds up to 10 characters.

To make the output left-aligned we need to make the number negative:

Console.WriteLine(”The value is {0,-10} – continue from here”,9999);

Displaying enumerated types

One very interesting feature of C# is the ability to display enumerated types.If you make your own enumeration wouldn’t it be nice if you could just print the values as a string literals? In fact you can as shown by the following example:

class MainClass
{
public enum Transport {Car = 1, Plane = 2, Motorcycle = 3}

public static void Main(string[] args)
{
Transport peopleMover = Transport.Plane;

Console.WriteLine("{0:G}",peopleMover);  // string literal
Console.WriteLine("{0:f}",peopleMover);   // flag -- not clear
Console.WriteLine("{0:d}",peopleMover);  // decimal
Console.WriteLine("{0:x}",peopleMover);   // hexadecimal
}
}

This outputs:

Plane

Plane

2
00000002

Basic number formatting

When no format is specified the String.Format method applies the “g” (General) type, which results in any value passed being rendered into a standard string. The following table shows what is possible:

If the table lists (error) it means that the String.Format method threw a String.Formatting exception. This happens if the number cannot be converted properly.

Custom number formatting

Of course, your preferred format is not listed above and you need a few modifications made. Not a problem. Custom formatting allows for any kind of number-to-string conversion you might need:

Date formats

The following table show the basic date formats obtained from calling DateTime.Now and then formatting the result. Note that different systems might produce different results depending on how the operating system is configured (think Chinese/Japanese/etc systems).

Custom Date formatting

The custom format strings allow DateTime objects to be formatted when the standard formatting strings are not useful and you need some special.

Image credit: easement

This is a post from Martijn's C# Coding Blog.

Occasionally you need to time the performance of a C# function to see if its as fast, or as slow, as you think it is. You could of course run your code through a profiler. But in situations that that would be overkill there exists a quick solution. Originally I looked at the standard DateTime class, but NET 2.0 introduced the  Stopwatch class which is much more suitable. In this post I look at how you can measure your functions performance down to the last fraction of a millisecond.

How not to measure your C# functions execution time

The DateTime.Now function returns the current time on your computer, down to the millisecond. A simple approach to measuring the time of a function would thus be:

DateTime Start = DateTime.Now;

for (int Lp = 0; Lp < 100; Lp++)
Console.WriteLine("Hello World!");

TimeSpan Elapsed = DateTime.Now - Start;
Console.WriteLine("Time Elapsed: {0} ms",Elapsed.Milliseconds);

The problem is that according to MSDN the resolution of the DateTime.Now function is 10+ milliseconds, and we need to call it twice! So that would introduce a 20+ ms swing in your runtime measurement. As our function calls are often likely to be a lot quicker to return than this 20ms window this isn’t good enough.

Another approach would be to use the system tickcount as kept by the Environment.TickCount variable, which is also kept in milliseconds. This keeps the number of milliseconds since the computer was started. Unfortunately it is kept in a signed int, so that every 49 days (how often do you reset your computer?) it is actually counting backwards. We can compensate for this by just taking off the most siginificant bit.

int Start = Environment.TickCount & Int32.MaxValue;

for (int Lp = 0; Lp < 100; Lp++)
Console.WriteLine("Hello World!");

int Elapsed = (Environment.TickCount &amp;amp;amp; Int32.MaxValue) - Start;
Console.WriteLine("Time Elapsed: {0} ms",Elapsed);

Using the Stopwatch class

The .NET 2.0 libraries introduced the Stopwatch class in System.Diagnostics which is much better suited for what we intend to do.  The class depends on the hardware available in your computer, if a high resolution timer is available is will use this, otherwise it will fall back to DateTime.Now.

You can check if the Stopwatch is using a high resolution timer by calling Stopwatch.IsHighResolution, and inquiry about the resolution in ticks per second by querying Stopwatch.Frequency.

// If we don't have a high resolution timer then Stopwatch will fall back
// to DateTime, which is much less reliable
if (Stopwatch.IsHighResolution)
Console.WriteLine("We have a high resolution timer available");

long frequency = Stopwatch.Frequency;
Console.WriteLine(" Timer frequency in ticks per second = {0}",frequency);

To start a Stopwatch simply call “Stopwatch.StartNew()” as shown below:

// Start the stopwatch
Stopwatch sw = Stopwatch.StartNew();

for (int Lp = 0; Lp < 100; Lp++)
Console.WriteLine("Hello World!");

// Stop the stopwatch
sw.Stop();

// Report the results
Console.WriteLine("Time used (float): {0} ms",sw.Elapsed.TotalMilliseconds);
Console.WriteLine("Time used (rounded): {0} ms",sw.ElapsedMilliseconds);

The ElapsedMilliseconds property returns a rounded number to the nearest full millisecond, the Elapsed.TotalMilliseconds property is a float that can return execution times to the partial millisecond.

Image credit: Stopwatch by Duy

This is a post from Martijn's C# Coding Blog.

Cool (Linux) applications have their own icon in the notification area. To add my own icon in the Gnome notification area using Mono only took a few lines of code. In the post below I show how you can add your icon and associate a tooltip and right click menu to it.

GTK provides the StatusIcon class to register your own icon in the notification area.

    StatusIcon  myStatusIcon;

You can provide and load your own icon, but for this example I used one of the GTK stock icons.

     myStatusIcon = StatusIcon.NewFromStock(Stock.Harddisk);  // I use a stock icon from Stock.*
                                                                                          // to avoid having to include an icon file
     myStatusIcon.Visible = true;                                             // Make sure we are displayed

Adding or changing a tooltip is as straighforward as assigning it:

      myStatusIcon.Tooltip = "Hello World ToolTip";                      // The message to show when the mouse hovers over the icon

To create a rightclick menu we need to register the PopupMenu event handler:

     myStatusIcon.PopupMenu += OnStatusIconPopupMenu;         // Link in the right click popup menu
     ...
     ...

    /* The Status Popup menu is shown when the user right clicks on the toolbar icon */

    protected void OnStatusIconPopupMenu(object sender, EventArgs e)
    {
        Menu popupMenu = new Menu();

        MenuItem helloItem = new MenuItem("About Hello World");
        helloItem.Show();
        helloItem.Activated += new EventHandler(OnHelloAboutActivated);

        popupMenu.Append(helloItem);
        popupMenu.Popup(null,null,null,3,Gtk.Global.CurrentEventTime);
    }

And that is really all there is to it. I have included the complete code below. If you create a new GTK solution in MonoDevelop you will end up with two files, Main.cs and MainWindows.Cs. Replace the MainWindow.CS file with the content below:

using System;
using Gtk;

public partial class MainWindow: Gtk.Window
{
	StatusIcon  myStatusIcon;
	AboutDialog aboutDialog;

	public MainWindow (): base (Gtk.WindowType.Toplevel)
	{

		/* The following lines create the notification area status icon */
		/* Make it visible and link in the right click popup menu       */ 

		myStatusIcon = StatusIcon.NewFromStock(Stock.Harddisk);  // I use a stock icon from Stock.*
		                                                         // to avoid having to include an icon file
		myStatusIcon.Tooltip = "Hello World ToolTip";            // The message to show when the mouse hovers over the icon
		myStatusIcon.Visible = true;                             // Make sure we are displayed
		myStatusIcon.PopupMenu += OnStatusIconPopupMenu;         // Link in the right click popup menu 

		/* Not necessary */
		Label AppWindowLabel = new Label("Hello World");
		this.Add(AppWindowLabel);

		Build ();
	}

	/* Called when the main application closes */

	protected void OnDeleteEvent (object sender, DeleteEventArgs a)
	{
		Application.Quit ();
		a.RetVal = true;
	}

	/* The Status Popup menu is shown when the user right clicks on the toolbar icon */

	protected void OnStatusIconPopupMenu(object sender, EventArgs e)
	{
		Menu popupMenu = new Menu();

		MenuItem helloItem = new MenuItem("About Hello World");
		helloItem.Show();
		helloItem.Activated += new EventHandler(OnHelloAboutActivated);

		popupMenu.Append(helloItem);
		popupMenu.Popup(null,null,null,3,Gtk.Global.CurrentEventTime);
	}

	/* If the user select the "About Hello World" menu option, we show the about dialog */

	protected void OnHelloAboutActivated(object sender, EventArgs e)
	{
		aboutDialog = new AboutDialog();

		aboutDialog.ProgramName = "The About Dialog Popup Demo";
		aboutDialog.Version = "1.0beta";
		aboutDialog.Comments = "The best things in life are simple!";
		aboutDialog.License = "Creative Commons";
		aboutDialog.Authors = new string[] { "Martijn Dijksterhuis" };
		aboutDialog.Website = "http://www.dijksterhuis.org";
		aboutDialog.Response += new ResponseHandler(OnHelloAboutClose);

		aboutDialog.Run();
	}

	/* Catch the "Close" and "X" button event from the about dialog box */

	protected void OnHelloAboutClose(object sender, ResponseArgs e)
	{
		if (e.ResponseId==ResponseType.Cancel || e.ResponseId==ResponseType.DeleteEvent)
		 aboutDialog.Destroy();
	}

}

This is a post from Martijn's C# Coding Blog.

The C# libraries already implement the Quicksort sorting algorithm. So for either a string or an int, sorting the list is as straightforward as calling “Sort”, as show in the below example.

using System;
using System.Collections.Generic;

namespace IComparer
{
    class MainClass
    {
        public static void Main(string[] args)
        {

            List<string> myList = new List<string>();

            myList.Add("z");
            myList.Add("c");
            myList.Add("a");
            myList.Add("d");
            myList.Add("b");

            myList.Sort();

            int cnt = 0;
            foreach(string letter in myList)
                Console.WriteLine("{0} = {1}",cnt++,letter);
        }
    }
}

This code will output:

0 = a
1 = b
2 = c
3 = d
4 = z

But what to do if you would like to reverse the sorting order ? We will have to define our own reverse string comparison routine by sub-classing IComparer. In the essential Compare function we simply call the standard String.Compare function with the parameters in reverse order:

using System;
using System.Collections.Generic;

namespace IComparer
{

    public class ReverseStringComparer : IComparer<string>
    {
        public int Compare(string x, string y)
        {
            // We reverse the result by flipping the input parameters
            return String.Compare(y,x);
        }
    }

    class MainClass
    {
        public static void Main(string[] args)
        {

            List<string> myList = new List<string>();

            myList.Add("z");
            myList.Add("c");
            myList.Add("a");
            myList.Add("d");
            myList.Add("b");

            ReverseStringComparer myComparer = new ReverseStringComparer();        

            myList.Sort(myComparer);

            int cnt = 0;
            foreach(string letter in myList)
                Console.WriteLine("{0} = {1}",cnt++,letter);
        }
    }
}

This code will output:

0 = z
1 = d
2 = c
3 = b
4 = a

Both strings and numbers are very basic types. If you want to sort a list build out of your own datatypes you will need to provide your own ICompare derived comparison class. In the following example we we create struct contained a basic personal record with name, familyname and age. We provide two comparers, one that can sort the list by FamilyName and a second one that sorts the people in the list by their age.

using System;
using System.Collections.Generic;

namespace IComparer
{

    struct Person
    {
        public string FamilyName;
        public string Name;
        public int    Age;
        public Person(string iFamilyName, string iName, int iAge)
        {
            FamilyName = iFamilyName; Name = iName; Age = iAge;
        }
    }

    class PersonComparerByName : IComparer<Person>
    {
        public int Compare(Person x, Person y)
        {
            return String.Compare(x.FamilyName,y.FamilyName);
        }
    }

    class PersonComparerByAge : IComparer<Person>
    {
        public int Compare(Person x, Person y)
        {
            return x.Age - y.Age;
        }
    }

    class MainClass
    {
        public static void Main(string[] args)
        {

            List<Person> myList = new List<Person>();

            myList.Add( new Person("Mulder","Jan",22) );
            myList.Add( new Person("Dijkstra","Hans",45) );
            myList.Add( new Person("Zomer","Nara",25) );
            myList.Add( new Person("Italy","Jaro",38) );
            myList.Add( new Person("Robert","Nico",15) );

            // Sort the people in the list by their last name
            PersonComparerByName myComparerName = new PersonComparerByName();
            myList.Sort(myComparerName);

            int cnt1 = 0;
            foreach(Person aPerson in myList)
                Console.WriteLine("{0} = {1}",cnt1++,aPerson.FamilyName);

            // Sort the people in the list by their age
            PersonComparerByAge myComparerAge = new PersonComparerByAge();
            myList.Sort(myComparerAge);

            int cnt2 = 0;
            foreach(Person aPerson in myList)
                Console.WriteLine("{0} = {1} {2}",cnt2++,aPerson.FamilyName,aPerson.Age);

        }
    }
}

When run, the above code will output:

0 = Dijkstra
1 = Italy
2 = Mulder
3 = Robert
4 = Zomer

0 = Robert 15
1 = Mulder 22
2 = Zomer 25
3 = Italy 38
4 = Dijkstra 45

This is a post from Martijn's C# Coding Blog.

When I finally had MonoDevelop compiled and installed — the promised debugging didn’t actually work. Bummer. I gave up, and went back to coding the old way (with ticker tape). This morning I checked out the latest SVN, installed it and ran it, just for laughs.

And behold as shown below — debugging actually worked. I can step and trace through the code, and set watches making MonoDevelop suddenly that much more useful to me.

The best thing? The Mono C# libraries are not black boxes but open source — you can step and trace directly into the Mono libraries themselves and find out what Mono is doing as you call library functions.

The problem with installing MonoDevelop 2.0alpha 2 is that the guides online don’t actually produce a working MonoDevelop installation. If you run MonoDevelop under Ubuntu like I do, the number of dependencies and sub-dependencies you need to resolve is large and I ended up compiling, re-compiling and changing version numbers of modules multiple times to find combinations that worked. In addition I had to change, add and resolve many missing library conflicts within Ubuntu as well.

Concluding: Yes, it is possible. Just do not expect a quick and easy install of MonoDevelop 2.0 alpha 2 on your Ubuntu installation.

This is fun only if you have plenty of spare time.

Some hints — this does not produce a working Mono Develop installation

• Remove Mono 1.9, MonoDevelop 1.0, and any and all other mono related things from your ubuntu installation before attempting to compile MonoDevelop 2.0 Alpha 2 to avoid conflicts down the road.
• Install mono 2.3, the debugger and mono develop from SVN, not from the packages provided on the website (they do not work)
• $ svn co svn://anonsvn.mono-project.com/source/trunk/mono
  $ svn co svn://anonsvn.mono-project.com/source/trunk/mcs
  $ svn co svn://anonsvn.mono-project.com/source/trunk/debugger
  $ svn co svn://anonsvn.mono-project.com/source/trunk/mono-addins
  $ svn co svn://anonsvn.mono-project.com/source/trunk/olive
  $ svn co svn://anonsvn.mono-project.com/source/trunk/monodevelop
• I installed gtk-sharp-2.12.5, gnome-sharp-2.20.0 and libglade-2.0.1 as support libraries
• Compile and install monodevelop last of all

Mono JIT compiler version 2.3 (/trunk/mono r121276 Thu Dec 11 13:04:53 CST 2008)
Copyright (C) 2002-2008 Novell, Inc and Contributors. www.mono-project.com

This is a post from Martijn's C# Coding Blog.

Another benefit of storing information in a tree structure is the opportunity for faster search times. In an array (or list) you need to traverse the whole array to discover if it contains a particular value. A well-balanced binary tree can drastically reduce the number of look-ups required.

Given the left set of numbers, the tree on the right is created. If a value is smaller than the root, it goes left, if a value is larger it goes right. If both the left and right nodes have been assigned already, we need to travel further down the tree and create new entries there.

In the tree above the longest route from the root of the tree (5) is to discover that it contains (6) which in this example takes just 4 steps. All other values can be found in 1-3 steps.

Balancing the tree

Several algorithms exist for balancing trees — but in this post we keep things simple: our tree does not balance itself as new values are inserted.

By re-balancing it is possible to ensure that the maximum depth of the tree stays constant. If we were to insert data in-order into the tree, the tree itself would become lopsided and that would reduce its use in searching. The greater the trees depth (maximum number of steps from the root) the longer a potential search would take, and in the most unfortunate instance it would be the same as for a linked list or array.

So to maximize this trees potential we would need our data insertion to be as random as possible.

The Tree Node Structure

Each node in our tree can be described by a very simple class:

       class BinaryTreeNode
        {
            public BinaryTreeNode Left;
            public BinaryTreeNode Right;
            public BinaryTreeNode Parent;
            public T Data;

            public BinaryTreeNode()
            {
                Left = null;
                Right = null;
                Parent = null;
            }
        }

We use a class, and not a struct as C# passes classes by reference, and structs by value. Passing by reference is the same as using pointers in C/C++. It allows us to dynamically add new entries — or remove them — and to traverse the tree.

Each node has the potential to link to another Left and Right node and it stores one Data unit.

Because we will be traveling through the tree non-recursively we also need to keep a link to the Parent node. This allows us to travel back up the tree if we have reached a dead end in our search.

Using Generics in a Binary Tree

To allow us to store any kind of data — not just integers, the actual Binary Tree class is implemented using Generics. You are free to define your own datastructure and store it in the tree.

class BinaryTree<T>

But how to sort our data? Because T can be anything, the compiler does not know how to compare two instances of T to each other. For our tree algorithm we need to know if:

T1 < T2
T1 == T2
T1 > T2

Generic sorting routines have the same problem, and the System class of C# provides a delegate function that we will use in our tree:

public delegate int Comparison<T>(T x,T y)

A sample implementation for comparing integers is provided in the class:

        /// <summary>
        /// For integer comparisons we provide a demonstration function.
        /// </summary>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <returns>&lt;0 for left smaller than right, &gt;0 if they are equal, +1 if right is larger than left</returns>

        public static int CompareFunction_Int(int left, int right)
        {
            return left - right;
        }

This function is passed to the class constructor on creation:

         BinaryTree<int> Test = new BinaryTree<int>(BinaryTree<int>.CompareFunction_Int);

If you use your own data type you will have to provide your own comparison function.

Insert Algorithm

Most of the work of building the tree is done in the insert algorithm.

The flowchart is a little long to insert in a blog post, but if you are interested you can find it here.

Custom Iterator

To retrieve all the values from the binary tree the BinaryTree class provides a custom iterator. The iterator it returns performs an ordered walk through the binary tree returning each data entry stored in order of increasing value.

            BinaryTree<int> Test = new BinaryTree<int>(BinaryTree<int>.CompareFunction_Int);

             /*...*/

            // Iterate over all members in the tree -- values are returned in sorted order
            foreach(int value in Test)
            {
                Console.WriteLine("Value: {0}", value);
            }

The code for the BinaryTree class is listed below, a small set of test routines is given in the TreeTest class.

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

namespace Developer.Collections
{

    /// <summary>
    /// The BinaryTree class implements a simple non-balanced sorted Binary Tree in C#
    /// </summary>
    /// <typeparam name="T">The tree can contain any type, but you are required to provide your own comparison function.</typeparam>

    class BinaryTree<T>
    {
        /// <summary>
        /// The tree is build up out of BinaryTreeNode instances
        /// </summary>

        class BinaryTreeNode
        {
            public BinaryTreeNode Left;
            public BinaryTreeNode Right;
            public BinaryTreeNode Parent;
            public T Data;

            public BinaryTreeNode()
            {
                Left = null;
                Right = null;
                Parent = null;
            }
        }

        BinaryTreeNode Root;
        Comparison<T> CompareFunction;

        /// <summary>
        /// The BinaryTree constructor requires that we pass a comparison function. We need one as generics can only
        /// be compared as equals, but not for order. The solution is to allow the caller to pass a suitable comparison
        /// function. We use the C# Comparison delegate for this (found in System.Collections)
        /// </summary>
        /// <param name="theCompareFunction">Pass a delegate function of the type Comparison to the function</param>

        public BinaryTree(Comparison<T> theCompareFunction)
        {
            Root = null;
            CompareFunction = theCompareFunction;
        }

        /// <summary>
        /// For integer comparisons we provide a demonstration function.
        /// </summary>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <returns>&lt;0 for left smaller than right, &gt;0 if they are equal, +1 if right is larger than left</returns>

        public static int CompareFunction_Int(int left, int right)
        {
            return left - right;
        }

        /// <summary>
        /// For string comparisons we provide a demonstration function
        /// </summary>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <returns>-1 for left smaller than right, 0 if they are equal, +1 if right is larger than left</returns>

        public static int CompareFunction_String(string left, string right)
        {
            return left.CompareTo(right);
        }

        /// <summary>
        /// The add function uses non-recursive tree traversal to find the next available insertion point
        /// </summary>
        /// <param name="Value">The value to insert into tree.</param>

        public void Add(T Value)
        {
            BinaryTreeNode child = new BinaryTreeNode();
            child.Data = Value;

            // Is the tree empty? Make the root the new child
            if (Root == null)
            {
                Root = child;
            }
            else
            {
                // Start from the root of the tree
                BinaryTreeNode Iterator = Root;
                while (true)
                {
                    // Compare the value to insert with the value in the current tree node
                    int Compare = CompareFunction(Value, Iterator.Data);
                    // The value is smaller or equal to the current node, we need to store it on the left side
                    // We test for equivalence as we allow duplicates (!)
                    if (Compare <= 0)
                        if (Iterator.Left != null)
                        {
                            // Travel further left
                            Iterator = Iterator.Left;
                            continue;
                        }
                        else
                        {
                            // An empty left leg, add the new node on the left leg
                            Iterator.Left = child;
                            child.Parent = Iterator;
                            break;
                        }
                    if (Compare > 0)
                        if (Iterator.Right != null)
                        {
                            // Continue to travel right
                            Iterator = Iterator.Right;
                            continue;
                        }
                        else
                        {
                            // Add the child to the right leg
                            Iterator.Right = child;
                            child.Parent = Iterator;
                            break;
                        }
                }

            }

        }

        /// <summary>
        /// This routine walks through the tree to see if the value given can be found.
        /// </summary>
        /// <param name="Value">The value to look for in the tree</param>
        /// <returns>True if found, False if not found</returns>

        public bool Find(T Value)
        {
            BinaryTreeNode Iterator = Root;
            while (Iterator != null)
            {
                int Compare = CompareFunction(Value, Iterator.Data);
                // Did we find the value ?
                if (Compare == 0) return true;
                if (Compare < 0)
                {
                    // Travel left
                    Iterator = Iterator.Left;
                    continue;
                }
                // Travel right
                Iterator = Iterator.Right;
            }
            return false;
        }

        /// <summary>
        /// Given a starting node, this routine will locate the left most node in the sub-tree
        /// If no further nodes are found, it returns the starting node
        /// </summary>
        /// <param name="start">The sub-tree starting point</param>
        /// <returns></returns>

        BinaryTreeNode FindMostLeft(BinaryTreeNode start)
        {
            BinaryTreeNode node = start;
            while (true)
            {
                if (node.Left != null)
                {
                    node = node.Left;
                    continue;
                }
                break;
            }
            return node;
        }

        /// <summary>
        /// Returns a list iterator of the elements in the tree implementing the IENumerator interface.
        /// </summary>
        /// <returns>IENumerator</returns>

        public IEnumerator<T> GetEnumerator()
        {
            return new BinaryTreeEnumerator(this);
        }

        /// <summary>
        /// The BinaryTreeEnumerator implements the IEnumerator allowing foreach enumeration of the tree
        /// </summary>

        class BinaryTreeEnumerator : IEnumerator<T>
        {
            BinaryTreeNode current;
            BinaryTree<T> theTree;

            public BinaryTreeEnumerator(BinaryTree<T> tree)
            {
                theTree = tree;
                current = null;
            }

            /// <summary>
            /// The MoveNext function traverses the tree in sorted order.
            /// </summary>
            /// <returns>True if we found a valid entry, False if we have reached the end</returns>
            public bool MoveNext()
            {
                // For the first entry, find the lowest valued node in the tree
                if (current == null)
                    current = theTree.FindMostLeft(theTree.Root);
                else
                {
                    // Can we go right-left?
                    if (current.Right != null)
                        current = theTree.FindMostLeft(current.Right);
                    else
                    {
                        // Note the value we have found
                        T CurrentValue = current.Data;

                        // Go up the tree until we find a value larger than the largest we have
                        // already found (or if we reach the root of the tree)
                        while (current != null)
                        {
                            current = current.Parent;
                            if (current != null)
                            {
                                int Compare = theTree.CompareFunction(current.Data,CurrentValue);
                                if (Compare < 0) continue;
                            }
                            break;
                        }

                    }
                }
                return (current != null);
            }

            public T Current
            {
                get
                {
                    if (current == null)
                        throw new InvalidOperationException();
                    return current.Data;
                }
            }

            object IEnumerator.Current
            {
                get
                {
                    if (current == null)
                        throw new InvalidOperationException();
                    return current.Data;
                }
            }

            public void Dispose() { }
            public void Reset() { current = null; }
        }

    }

    class TreeTest
    {
        static void Main(string[] args)
        {
            BinaryTree<int> Test = new BinaryTree<int>(BinaryTree<int>.CompareFunction_Int);

            // Build the tree
            Test.Add(5);
            Test.Add(2);
            Test.Add(1);
            Test.Add(3);
            Test.Add(3); // Duplicates are OK
            Test.Add(4);
            Test.Add(6);
            Test.Add(10);
            Test.Add(7);
            Test.Add(8);
            Test.Add(9);

            // Test if we can find values in the tree
            for (int Lp = 1; Lp <= 10; Lp++)
                Console.WriteLine("Find ({0}) = {1}", Lp,Test.Find(Lp));

            // Test if we can find a non-existing value
            Console.WriteLine("Find (999) = {0}", Test.Find(999));

            // Iterate over all members in the tree -- values are returned in sorted order
            foreach(int value in Test)
            {
                Console.WriteLine("Value: {0}", value);
            }

        }
    }

}

This is a post from Martijn's C# Coding Blog.

This article will go into how to create a hash of your passwords and how salting them makes them more secure.

What is a hash?

A hash function turns “Hello World” into “3964322768″. And it does that every time you run that same string through the hash function. How it does that depends on the hash algorithm, and so does the “3964322768″ result.

Different hash function return different results, but given the same data the same function always returns the same result.

Now imagine transferring a block of 2Kb of data across the Internet — at the end of it you include an extra hash. The receiver can check if the data received was all transferred correctly, if a bit had fallen over the data block would have generated a different hash.

On collisions

In the “old days” CRC16 was used to ensure that data was being transmitted correctly over telephone and serial lines. As modems became faster and the data send increased collisions became more frequent, leading to corrupted transfers. The CRC-16 was a 16-bit value, so it could only generate 2^16 = 65535 unique values.

By making the hash longer the chance that two sets of data share the same hash value (a collision) decreases. It is important to realize that this chance will never reach zero! It is entirely (though often unlikely) possible that your program will have two strings that generate the same hash.

Using hashes to store passwords

Hashes are useful as a one-way method to store passwords. In a typical scenario a user types his password and the system generates the hash and compares this with a hash stored on file.

It is not possible to reverse the password from a hash. Thus if someone gets hold of the password file they cannot reverse the original passwords.

Salting the hash

Hashes however are still open to one of the oldest attacks: the dictionary attack. Your system will likely lock out a users after several failed password attempts. If however through a security breach an attacker obtains your hashed password file (or part thereof) it is possible to apply one of many standard dictionaries against the found hashes:

1. Obtain hashed passwords (through online snooping, hacking)
2. Use dictionary software which contains pre-computed hash values for common passwords
3. See if the result matches , if so : password found
4. The hacker can now login and impersonate the user

The dictionary attack can be blunted. By adding a unique salt to each hash the attacker needs to re-calculate the dictionary for each users password, greatly increasing the attack time.

A salt is a random set of bytes which are added to the data set before calculating the hash.

1. User enters password for the first time
2. The system adds a salt to the password (for example 4 bytes of random data)
3. The system generates and stores the hash together with the salt

When the user returns for another login the system does the following:

1. The users enters the password
2. The system looks up the stored hash + salt
3. The system tries if a new hash of the given password + salt matches the stored hash
4. If they match the user can login

A Salted Hash implementation in C#

The following implementation demonstrates how you can implement a Salted Hash in C#. The class defaults to using SHA256Managed hash algorithm, and a salt size of 32 bits. You can however call the class with any other HashAlgorithm derived class (such as for example: SHA1Managed,SHA256Managed, SHA384Managed, SHA512Managed and MD5CryptoServiceProvider) and specify a salt size of any length.

The SaltedHash class provides two routines that do all the leg work:

void GetHashAndSalt(byte[] Data, out byte[] Hash, out byte[] Salt)

This routine generates the hash and a random salt for a given set of bytes.

bool VerifyHash(byte[] Data, byte[] Hash, byte[] Salt)

This routine checks if the data passed, together with the stored salt will generate the same hash as we had earlier calculated.

For convenience two more functions allow us to work with strings directly instead of byte arrays:

public void GetHashAndSaltString(string Data, out string Hash, out string Salt)

This routine takes a C# hash string and returns both the Hash and Salt as Base-64 encoded string.

public bool VerifyHashString(string Data, string Hash, string Salt)

The counterpart to the GetHashAndSaltString function, this routine allows us to use verify whether a string returns the same hash with the given salt.

using System;
using System.Security.Cryptography;
using System.Text;

namespace SaltedHash
{
    class SaltedHash
    {
        HashAlgorithm HashProvider;
        int SalthLength;

        /// <summary>
        /// The constructor takes a HashAlgorithm as a parameter.
        /// </summary>
        /// <param name="HashAlgorithm">
        /// A <see cref="HashAlgorithm"/> HashAlgorihm which is derived from HashAlgorithm. C# provides
        /// the following classes: SHA1Managed,SHA256Managed, SHA384Managed, SHA512Managed and MD5CryptoServiceProvider
        /// </param>

        public SaltedHash(HashAlgorithm HashAlgorithm, int theSaltLength)
        {
            HashProvider = HashAlgorithm;
            SalthLength = theSaltLength;
        }

        /// <summary>
        /// Default constructor which initialises the SaltedHash with the SHA256Managed algorithm
        /// and a Salt of 4 bytes ( or 4*8 = 32 bits)
        /// </summary>

        public SaltedHash() : this(new SHA256Managed(), 4)
        {
        }

        /// <summary>
        /// The actual hash calculation is shared by both GetHashAndSalt and the VerifyHash functions
        /// </summary>
        /// <param name="Data">A byte array of the Data to Hash</param>
        /// <param name="Salt">A byte array of the Salt to add to the Hash</param>
        /// <returns>A byte array with the calculated hash</returns>

        private byte[] ComputeHash(byte[] Data, byte[] Salt)
        {
            // Allocate memory to store both the Data and Salt together
            byte[] DataAndSalt = new byte[Data.Length + SalthLength];

            // Copy both the data and salt into the new array
            Array.Copy(Data, DataAndSalt, Data.Length);
            Array.Copy(Salt, 0, DataAndSalt, Data.Length, SalthLength);

            // Calculate the hash
            // Compute hash value of our plain text with appended salt.
            return HashProvider.ComputeHash(DataAndSalt);
        }

        /// <summary>
        /// Given a data block this routine returns both a Hash and a Salt
        /// </summary>
        /// <param name="Data">
        /// A <see cref="System.Byte"/>byte array containing the data from which to derive the salt
        /// </param>
        /// <param name="Hash">
        /// A <see cref="System.Byte"/>byte array which will contain the hash calculated
        /// </param>
        /// <param name="Salt">
        /// A <see cref="System.Byte"/>byte array which will contain the salt generated
        /// </param>

        public void GetHashAndSalt(byte[] Data, out byte[] Hash, out byte[] Salt)
        {
            // Allocate memory for the salt
            Salt = new byte[SalthLength];

            // Strong runtime pseudo-random number generator, on Windows uses CryptAPI
            // on Unix /dev/urandom
            RNGCryptoServiceProvider random = new RNGCryptoServiceProvider();

            // Create a random salt
            random.GetNonZeroBytes(Salt);

            // Compute hash value of our data with the salt.
            Hash = ComputeHash(Data, Salt);
        }

        /// <summary>
        /// The routine provides a wrapper around the GetHashAndSalt function providing conversion
        /// from the required byte arrays to strings. Both the Hash and Salt are returned as Base-64 encoded strings.
        /// </summary>
        /// <param name="Data">
        /// A <see cref="System.String"/> string containing the data to hash
        /// </param>
        /// <param name="Hash">
        /// A <see cref="System.String"/> base64 encoded string containing the generated hash
        /// </param>
        /// <param name="Salt">
        /// A <see cref="System.String"/> base64 encoded string containing the generated salt
        /// </param>

        public void GetHashAndSaltString(string Data, out string Hash, out string Salt)
        {
            byte[] HashOut;
            byte[] SaltOut;

            // Obtain the Hash and Salt for the given string
            GetHashAndSalt(Encoding.UTF8.GetBytes(Data), out HashOut, out SaltOut);

            // Transform the byte[] to Base-64 encoded strings
            Hash = Convert.ToBase64String(HashOut);
            Salt = Convert.ToBase64String(SaltOut);
        }

        /// <summary>
        /// This routine verifies whether the data generates the same hash as we had stored previously
        /// </summary>
        /// <param name="Data">The data to verify </param>
        /// <param name="Hash">The hash we had stored previously</param>
        /// <param name="Salt">The salt we had stored previously</param>
        /// <returns>True on a succesfull match</returns>

        public bool VerifyHash(byte[] Data, byte[] Hash, byte[] Salt)
        {
            byte[] NewHash = ComputeHash(Data, Salt);

            //  No easy array comparison in C# -- we do the legwork
            if (NewHash.Length != Hash.Length) return false;

            for (int Lp = 0; Lp < Hash.Length; Lp++ )
                if (!Hash[Lp].Equals(NewHash[Lp]))
                    return false;

            return true;
        }

        /// <summary>
        /// This routine provides a wrapper around VerifyHash converting the strings containing the
        /// data, hash and salt into byte arrays before calling VerifyHash.
        /// </summary>
        /// <param name="Data">A UTF-8 encoded string containing the data to verify</param>
        /// <param name="Hash">A base-64 encoded string containing the previously stored hash</param>
        /// <param name="Salt">A base-64 encoded string containing the previously stored salt</param>
        /// <returns></returns>

        public bool VerifyHashString(string Data, string Hash, string Salt)
        {
            byte[] HashToVerify = Convert.FromBase64String(Hash);
            byte[] SaltToVerify = Convert.FromBase64String(Salt);
            byte[] DataToVerify = Encoding.UTF8.GetBytes(Data);
            return VerifyHash(DataToVerify, HashToVerify, SaltToVerify);
        }

    }

    /// <summary>
    /// This little demo code shows how to encode a users password.
    /// </summary>

    class SaltedHashDemo
    {
        public static void Main(string[] args)
        {
            // We use the default SHA-256 & 4 byte length
            SaltedHash demo = new SaltedHash();

            // We have a password, which will generate a Hash and Salt
            string Password = "MyGlook234";
            string Hash;
            string Salt;

            demo.GetHashAndSaltString(Password, out Hash, out Salt);
            Console.WriteLine("Password = {0} , Hash = {1} , Salt = {2}", Password, Hash, Salt);

            // Password validation
            //
            // We need to pass both the earlier calculated Hash and Salt (we need to store this somewhere safe between sessions)

            // First check if a wrong password passes
            string WrongPassword = "OopsOops";
            Console.WriteLine("Verifying {0} = {1}", WrongPassword, demo.VerifyHashString(WrongPassword, Hash, Salt));

            // Check if the correct password passes
            Console.WriteLine("Verifying {0} = {1}", Password, demo.VerifyHashString(Password, Hash, Salt));

        }
    }

}

Image credit: Looking Glass

This is a post from Martijn's C# Coding Blog.

In a previous post we looked at how we could use System.Net.NetworkInformation to determine the machines local IP addresses, but there is much more stored in here.

The code below steps through each network interface on my machine:

Interface information for mymachine.mydomain.com
NetBIOS node type: Unknown
——————————————————
Name: Local Area Connection
Description: ASUSTeK/Broadcom 440x 10/100 Integrated Controller – Packet Scheduler Miniport
Network Interface Type: Ethernet
Physical Address: 000EA99F2D04
Adapter ID: {34F1A99A-3449-4290-8FFF-C1C62211696A}
Receive only: False
Status: Up
Speed: 100000000
Properties:
|DNS Addresses: 255.255.255.255
|DNS Suffic:
|DNS Enabled: False
|Dynamic DNS Enabled: True
|DHPC Server Addresses: 255.255.255.255
|UniCast Addresses: 10.0.0.6 192.168.1.6
|AnyCast Addresses:
|Supports multi-cast: True
|Multicast Addresses: 224.0.0.1 239.255.255.250
|Gateway Addresses: 10.0.0.253
+IPV4 Properties:
|Interface Index: 2
|Automatic Private Addressing Active: False
|Automatic Private Addressing Enabled: True
|DHCP Enabled: False
|Forwarding Enabled: False
|MTU Size: 1500
\Uses Wins: False
+IPV6 is not implemented

For brevity I have omitted the local loopback adaptor.

The Mono implementation of System.Net.NetworkInformation is spotty at best. This has much to do with the fact that on Linux much information isn’t easily stored in one central location. As can be seen from the comments in the Mono 2.01 source code:

               [MonoTODO ("Always returns an empty collection.")]
                public override IPAddressCollection DhcpServerAddresses {
                        get {
                                // There are lots of different DHCP clients
                                // that all store their configuration differently.
                                // I'm not sure what to do here.
                                return new IPAddressCollection ();
                        }
                }

                [MonoTODO ("Always returns an empty collection.")]
                public override IPAddressCollection DnsAddresses {
                        get {
                                // XXX: Parse /etc/resolv.conf, I suppose.
                                return new IPAddressCollection ();
                        }
                }

The following code runs under both .NET & Mono and gives you a quick overview of the kinds of adapter information provided by System.Net.NetworkInformation. It is also possible to query each adapter for usage statistics — if you would like to know how many bytes it has send, but we won’t go there.

using System;
using System.Net;
using System.Net.NetworkInformation;
using System.Collections.Generic;
using System.Text;

namespace Examples.System.Net.NetworkInformation.IfConfig
{
    public class IfConfig
    {
        public static bool DetectMono()
        {
            int p = (int)Environment.OSVersion.Platform;
            return (p == 4) || (p == 128);
        }

        public static void Main(string[] args)
        {
            // Mono's implementation of NetworkInformation is spotty, many values just return hard coded defaults
            // or throw an NotImplementedExceptions
            bool IsMono = DetectMono();

            // Global IP settings
            IPGlobalProperties global_properties = IPGlobalProperties.GetIPGlobalProperties();
            Console.WriteLine("Interface information for {0}.{1}", global_properties.HostName, global_properties.DomainName);
            Console.WriteLine("NetBIOS node type: {0}", global_properties.NodeType);

            //Gateway IP
            NetworkInterface[] adapters = NetworkInterface.GetAllNetworkInterfaces();
            foreach (NetworkInterface adapter in adapters)
            {
                Console.WriteLine("------------------------------------------------------");
                Console.WriteLine("Name: {0}", adapter.Name);
                Console.WriteLine("Description: {0}", adapter.Description);
                Console.WriteLine("Network Interface Type: {0}", adapter.NetworkInterfaceType);
                Console.WriteLine("Physical Address: {0}", adapter.GetPhysicalAddress());
                Console.WriteLine("Adapter ID: {0}", adapter.Id);
                Console.WriteLine("Receive only: {0}", adapter.IsReceiveOnly);
                Console.WriteLine("Status: {0}", adapter.OperationalStatus);

                if (!IsMono) Console.WriteLine("Speed: {0}", adapter.Speed); // 100 Mb is really a lot of zeros

                IPInterfaceProperties properties = adapter.GetIPProperties();
                Console.WriteLine("Properties: ");

                Console.Write("|DNS Addresses: ");
                foreach (IPAddress DnsServer in properties.DhcpServerAddresses)
                    Console.Write("{0} ", DnsServer);
                Console.WriteLine();

                Console.WriteLine("|DNS Suffic: {0}", properties.DnsSuffix);

                Console.WriteLine("|DNS Enabled: {0}", properties.IsDnsEnabled);
                Console.WriteLine("|Dynamic DNS Enabled: {0}", properties.IsDynamicDnsEnabled);

                Console.Write("|DHPC Server Addresses: ");
                foreach (IPAddress DhcpServer in properties.DhcpServerAddresses)
                    Console.Write("{0} ", DhcpServer);
                Console.WriteLine();

                Console.Write("|UniCast Addresses: ");
                foreach (IPAddressInformation uniCast in properties.UnicastAddresses)
                    Console.Write("{0} ", uniCast.Address);
                Console.WriteLine();

                Console.Write("|AnyCast Addresses: ");
                foreach (IPAddressInformation anyCast in properties.AnycastAddresses)
                    Console.Write("{0} ", anyCast.Address);
                Console.WriteLine();

                Console.WriteLine("|Supports multi-cast: {0}", adapter.SupportsMulticast);
                Console.Write("|Multicast Addresses: ");
                foreach (IPAddressInformation multiCast in properties.MulticastAddresses)
                    Console.Write("{0} ", multiCast.Address);
                Console.WriteLine();

                Console.Write("|Gateway Addresses: ");
                foreach (GatewayIPAddressInformation GateWay in properties.GatewayAddresses)
                    Console.Write("{0} ", GateWay.Address);
                Console.WriteLine();

                if (adapter.Supports(NetworkInterfaceComponent.IPv4) == true)
                {
                    IPv4InterfaceProperties IPV4Props = properties.GetIPv4Properties();
                    // Loopback device does not have any property information associated
                    Console.WriteLine("+IPV4 Properties: ");
                    if (IPV4Props != null)
                    {
                        Console.WriteLine(" |Interface Index: {0}", IPV4Props.Index);
                        Console.WriteLine(" |Automatic Private Addressing Active: {0}", IPV4Props.IsAutomaticPrivateAddressingActive);
                        Console.WriteLine(" |Automatic Private Addressing Enabled: {0}", IPV4Props.IsAutomaticPrivateAddressingEnabled);
                        Console.WriteLine(" |DHCP Enabled: {0}", IPV4Props.IsDhcpEnabled);
                        Console.WriteLine(" |Forwarding Enabled: {0}", IPV4Props.IsForwardingEnabled);
                        Console.WriteLine(" |MTU Size: {0}", IPV4Props.Mtu);
                        Console.WriteLine(" \\Uses Wins: {0}", IPV4Props.UsesWins);
                    }
                    else
                    {
                        Console.WriteLine(" |Device has no IPv4 properties");
                    }
                }
                else
                {
                    Console.WriteLine("+IPV4 is not implemented");
                }

                if (!IsMono && adapter.Supports(NetworkInterfaceComponent.IPv6) == true)
                {
                    IPv6InterfaceProperties IPV6Props = properties.GetIPv6Properties();
                    Console.WriteLine("+IPV6 Properties: ");
                    if (IPV6Props != null)
                    {
                        Console.WriteLine("+IPV6 Properties: ");
                        Console.WriteLine(" |Interface Index: {0}", IPV6Props.Index);
                        Console.WriteLine(" \\MTU Size: {0}", IPV6Props.Mtu);
                    }
                    else
                    {
                        Console.WriteLine(" |Device has no IPv6 properties");
                    }
                }
                else
                {
                    Console.WriteLine("+IPV6 is not implemented");
                }

            }

        }
    }
}

This is a post from Martijn's C# Coding Blog.

C# originally provided basic system information through the System.Net.DNS class. By querying the DNS “GetHostEntry” we could also discover the local IP addresses. The problem is that under Mono this only returns the local loop-back connector making this not a portable solution.

In .NET 2.0 the System.Net.NetworkInformation class was added, which allows you to browse all the network adapters and query their configuration in much greater detail.

The code below shows both methods for querying the local configuration:

using System;
using System.Net;
using System.Net.NetworkInformation;
using System.Collections.Generic;
using System.Net.Sockets;

namespace IPLookup
{
    class MainClass
    {
        public static IPAddress[] GetAllUnicastAddresses_Old()
        {
            // By passing an empty string to GetHostEntry we receive all the IP addresses on the local machine
            // This breaks on Mono
            IPHostEntry LocalEntry = Dns.GetHostEntry("");
            return LocalEntry.AddressList;
        }

        public static IPAddress[] GetAllUnicastAddresses_New()
        {
            // This works on both Mono and .NET , but there is a difference: it also
            // includes the LocalLoopBack so we need to filter that one out
            List<IPAddress> Addresses = new List<IPAddress>();
            // Obtain a reference to all network interfaces in the machine
            NetworkInterface[] adapters = NetworkInterface.GetAllNetworkInterfaces();
            foreach (NetworkInterface adapter in adapters)
            {
                IPInterfaceProperties properties = adapter.GetIPProperties();
                foreach (IPAddressInformation uniCast in properties.UnicastAddresses)
                {
                    // Ignore loop-back addresses & IPv6
                    if (!IPAddress.IsLoopback(uniCast.Address) && uniCast.Address.AddressFamily!= AddressFamily.InterNetworkV6)
                      Addresses.Add(uniCast.Address);
                }

            }
            return Addresses.ToArray();
        }

        public static void Main(string[] args)
        {
            IPAddress[] Adresses = GetAllUnicastAddresses_Old();
            foreach (IPAddress Adres in Adresses)
            {
                Console.WriteLine("OLD IP Address: {0}", Adres);
            }

            IPAddress[] Adresses2 = GetAllUnicastAddresses_New();
            foreach (IPAddress Adres in Adresses2)
            {
                Console.WriteLine("NEW IP Address: {0}", Adres);
            }
        }

    }
}

This is a post from Martijn's C# Coding Blog.

In the dark ages before the Internet there was “war-dialing”: randomly calling telephone numbers in the hope that on the other side a computer modem would pick up. War Dialing was glamorized by the movie “Wargames” but portscanning is just like that: you too can help the world narrowly avoid nuclear Armageddon. This article shows how you can build a simple Portscanner in C#.

And with simple we mean simple, this is no NMAP. But given an IP address or domain name address it will slowly scan each available port of the target computer to see if its open.

Port scanning www.hinet.net (203.66.88.89)
Scanning port 0 : closed
Scanning port 1 : closed
Scanning port 2 : closed
Scanning port 3 : closed
....
Scanning port 7 :

Scanning is done by connect scanning the target computer. The program tries to build a connection to the IP address / port of the target. If it succeeds the port is open.

There is a gotcha here : The .NET implementation of TCPClient.Close() function does not actually close the connection properly. So we need to do the additional steps of obtaining the stream representing the connection and closing this as well before calling TCPClient.Close.

When starting the program you need to pass a domain name or IP address on the command line. We use a little regular expression magic in the IsIpAddress() method to determine if we were passed a valid IP address.

If a domain name was passed the LookupDNSName() method uses DNS to locate the matching IP address. Since more than one IP address can be represent a single domain name, the first one returned is selected.

The actual scanning is done by ScanPort(), a successful connection makes it return true.

using System;
using System.Net;
using System.Net.Sockets;
using System.Text.RegularExpressions;

namespace PortScanner
{
    class Program
    {

        // IsIpAddress
        //
        // The following routine returns true if a given string is a valid IP address 

        static bool IsIpAddress(string Address)
        {
            // The following pattern matches an IP address
            Regex IpMatch = new Regex(@"\b(?:\d{1,3}\.){3}\d{1,3}\b");
            return IpMatch.IsMatch(Address);
        }

        // LookupDNSName
        //
        // 

        static bool LookupDNSName(string ScanAddress, out IPAddress ScanIPAddress)
        {
            ScanIPAddress = null;
            IPHostEntry NameToIpAddress;

            try
            {
                // Lookup the address we are going to scan
                NameToIpAddress = Dns.GetHostEntry(ScanAddress);
            }
            catch(SocketException)
            {
                // Thrown when we are unable to lookup the name
                return false;
            }

            // Pick the first address in the list , there should be at least 1
            if (NameToIpAddress.AddressList.Length > 0)
            {
                ScanIPAddress = NameToIpAddress.AddressList[0];
                return true;
            }

            return false;
        }

        static bool ScanPort(IPAddress Address, int Port)
        {
            TcpClient Client = new TcpClient();
            try
            {
                // Attempt to connect to the given address + port
                Client.Connect(Address, Port);

                // This may seem like an avoidable step -- but TcpClient.Close does not
                // actually close the underlying connection
                // http://support.microsoft.com/default.aspx?scid=kb%3Ben-us%3B821625

                NetworkStream ClientStream = Client.GetStream();
                ClientStream.Close();

                // Free the TCPClient resource
                Client.Close();
            }
            catch(SocketException)
            {
                // Assume that a socket exception means the connection failed
                // Client.Connect returns a void (so provides no insights into
                // what it was doing)
                return false;
            }
            return true;
        }

        static void Main(string[] args)
        {
            String ScanAddress;
            IPAddress ScanIPAddress;

            try
            {
                // Try to read the scan address from the command line, or default to localhost
                if (args.Length != 0)
                    ScanAddress = args[0];
                else
                    ScanAddress = "127.0.0.1";

                // Both a hostname or an IP address are fine
                if (IsIpAddress(ScanAddress))
                {
                    ScanIPAddress = IPAddress.Parse(ScanAddress);
                }
                else
                if (!LookupDNSName(ScanAddress,out ScanIPAddress))
                {
                    Console.WriteLine("Error looking up {0}",ScanAddress);
                    return;
                }

                // Report what we are going to do
                Console.WriteLine("Port scanning {0} ({1})", ScanAddress, ScanIPAddress.ToString());

                // Scan all the possible posts
                for (int Port = IPEndPoint.MinPort; Port < IPEndPoint.MaxPort; Port++)
                {
                    Console.Write("Scanning port {0} : ", Port);
                    if (ScanPort(ScanIPAddress, Port))
                        Console.WriteLine("OPEN");
                    else
                        Console.WriteLine("closed");
                }

                // Close Up
                Console.WriteLine("Finished scanning all ports");

            }
            catch (Exception e)
            {
                Console.WriteLine("Exception caught!");
                Console.WriteLine("Source : " + e.Source);
                Console.WriteLine("Message : " + e.Message);
            }
        }
    }
}

As there are some 2^16 addresses (IPEndPoint.MinPort = 0 / IPEndPoint.MaxPort = 65536) this program will take its quite a bit of time to scan a whole machine. Also, if a port is closed (or hidden by a firewall) the TCPClient will need to wait for a timeout before being able to report this.

One possible solution to this would be to scan multiple ports simultaneously with a set of ThreadPool workers as most of the time the main thread is waiting for the TCP stack.

Image credit: makelessnoise

This is a post from Martijn's C# Coding Blog.