The idea is that if the user enters one or more characters that the Textbox will search its list of suggestions. In this test implementation this is done through a simple List<>. Ultimately my list will contain many thousands of items and I will need to replace the List<> with a more efficient search algorithm.

In the below example code typing a single “W” will expand to “Waterland”, if you continue typing beyond the final “d” it will suggest “Waterland Investments”. Type a “T” and it will branch to “Waterland Telecommunication Systems”.

using System;
using System.Collections.Generic;
using System.Text;
using System.Windows.Forms;

namespace Dijksterhuis.org
{
    class AutoSuggestControl : TextBox
    {
        List<string> Suggestions;
        int PreviousLength; 

        // V1.0 We are using a simple sorted list for the suggestions
        public AutoSuggestControl() : base()
        {
            Suggestions = new List<string>();

            // We keep track of the previous length of the string
            // If the user tries to delete characters we do not interfere
            PreviousLength = 0; 

            // Very basic list, too slow to be suitable for systems with many entries
            Suggestions.Add("Waterland");
            Suggestions.Add("Waterland Investments");
            Suggestions.Add("Waterland Telecommuncation Systems");
            Suggestions.Sort();
        }

        /// <summary>
        /// Search through the collection of suggestions for a match
        /// </summary>
        /// <param name="Input"></param>
        /// <returns></returns>

        private string FindSuggestion(string Input)
        {
            if (Input != "")
            foreach (string Suggestion in Suggestions)
            {
                if (Suggestion.StartsWith(Input))
                    return Suggestion;
            }
            return null;
        }

        /// <summary>
        /// We only interfere after receiving the OnTextChanged event.
        /// </summary>
        /// <param name="e"></param>
        protected override void OnTextChanged(EventArgs e)
        {
            base.OnTextChanged(e);

            // We don't do anything if the user is trying to shorten the sentence
            int CursorPosition = SelectionStart;
            if (Text.Length > PreviousLength && CursorPosition >= 0)
            {
                string Suggestion = FindSuggestion(Text.Substring(0, CursorPosition));
                if (Suggestion != null)
                {
                    // Set the contents of the textbox to the suggestion
                    Text = Suggestion;
                    // Setting text puts the cursor at the beginning of the textbox, so we need to reposition it
                    Select(CursorPosition, 0);
                }
            }
            PreviousLength = Text.Length;
        }

    }
}

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

First of all, C# already has a generic LinkedList implementation, found in the System.Collections class. If you are looking for that class, the MSDN website provides a solid introduction.

After building a basic link list class in a previous post, I decided to extend it. To avoid cloning the C# System.Collections class completely I used the Java LinkedList specification instead to roll my own. That meant implementing an iterator and methods such as AddFirst, AddLast, Clear, ToArray etc. To be able to support this the internal working of my earlier class had to be reworked substantially. I have included the complete code for reference below.

My main purpose for writing this code was to experiment with using NUnit. NUnit is a testing framework which allows you to create unit tests for your code. As you implement a method you write a small test to ensure that it works correctly. Because you are adding functionality to the class as you write new code the underlying methods might change in unexpected ways. Unit tests help you catch bugs introduced this way.

In earlier posts I commented on how to use NUnit if you are coding in Visual Studio C# 2008 Express ; and how to use NUnit if you are building your applications with MonoDevelop so if you are having trouble setting this up please refer to these.

Creating new and interesting bugs

As a late optimization to my LinkedList class I added “Search Backwards” logic to the “Get(n)” method.

As you can guess, the “Get(n)” method returns the n^th item in the list. To find it the n^th element we need to step through the list from the start. If we work out that the item is closer the tail of the list we can save some time by stepping backwards through the list instead. Unit testing helped here as I had made a small bit significant error in how I calculated the distance from the tail. Several tests immediately failed as they now received unexpected results.

Creating the Unit Tests

The best place to put your tests is in a separate class file. As can be seen in the code snippet below the first thing we need to do is to include the NUnit.Framework in the code. The first thing to notice about this class is that it has a [TestFixture] attribute – this is how we indicate that the class contains test code. The class has to be public. As we can run NUnit tests independently of your programs main routine, NUnit will simply load your programs classes and use the [TestFixture] attribute to discover any and all tests classes.

Each method containing a valid test has a [Test] attribute associated with it. Again, NUnit will simply scan the [TestFixture] classes for any method labeled with a [Test] attribute.

In the example below I included a very simple test for the Add() method of my linked list. After adding 2 items to the LinkedList, the total number of items has to be 2. Testing is done through the Assert class, if the Assert test fails, NUnit will flag the test as failed. Some other common Assert methods are: AreEqual(a,b) / AreNotEquels(a,b) / Equals / IsTrue / IsFalse etc.

using System;
using System.Text;
using NUnit.Framework;

namespace LinkedListJavaStyle
{
    /// <summary>
    /// LinkedList_NUnit is a class implementing a set of unit tests for each of the methods supported by the LinkedList class
    /// </summary>

    [TestFixture]
    public class LinkedList_NUnit
    {

        [Test]
        public void TestLinkedList_add()
        {
            LinkedList<string> Test = new LinkedList<string>();
            Test.Add("Hello World");
            Test.Add("The world today");
            Assert.AreEqual(2, Test.Size());
        }
}

The complete LinkedListClass.cs and set of tests (LinkedList_NUnit.cs) are given below:

LinkedList.cs

using System;
using System.Text;
using NUnit.Framework;

namespace LinkedListJavaStyle
{
    /// <summary>
    /// LinkedList_NUnit is a class implementing a set of unit tests for each of the methods supported by the LinkedList class
    /// </summary>

    [TestFixture]
    public class LinkedList_NUnit
    {

        [Test]
        public void TestLinkedList_add()
        {
            LinkedList<string> Test = new LinkedList<string>();
            Test.Add("Hello World");
            Test.Add("The world today");
            Assert.AreEqual(2, Test.Size());
        }
}

The complete LinkedListClass and set of tests are given below:

// LinkedList.cs created with MonoDevelop
// User: martijn at 10:02 AM 12/30/2008

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

namespace LinkedListJavaStyle
{

    /// <summary>
    /// LinkedListElement is the memory structure used by the LinkedList class for storing each list cell.
    /// Every element contains a pointer to the previous and next element and a copy of the data.
    /// </summary>
    /// <typeparam name="T">The same as for LinkedList</typeparam>

    class LinkedListNode<T>
    {
        public T Data;
        public LinkedListNode<T> Prev;
        public LinkedListNode<T> Next;

        public LinkedListNode(T Data)
        {
            this.Data = Data;
        }
    }

    /// <summary>
    /// Linked List implementation following the model layed out by the Java LinkedList Class. Implements all list operations and permits
    /// all elements (including null). Operations that need to enter the list will travel through the list from beginning to end until
    /// the required offset is found (or from the tail if the distance is shorter).
    ///
    /// The class is implemented as a double linked list.
    /// </summary>
    /// <typeparam name="T">This class accepts any type you would like to use for the generic.</typeparam>

    class LinkedList<T>
    {

        LinkedListNode<T> Head;
        LinkedListNode<T> Tail;
        int LinkedList_Size;

        /// ---------------------------------------------------------------------------------------
        /// <summary>
        /// Constructor
        /// </summary>

        public LinkedList()
        {
            Head = null;
            Tail = null;
            LinkedList_Size = 0;
        }

        /// <summary>
        /// Constructs a list containing the elements of the specified collection, in the order that they are
        /// returned by the collections itterator.
        /// </summary>
        /// <param name="collection">An array of type T containing the elements to be added to the list</param>

        public LinkedList(T[] collection)
        {
            Head = null;
            Tail = null;
            LinkedList_Size = 0;
            AddAll_Internal(Tail, collection);
        }

        /// <summary>
        /// Private function which inserts a T element before the offset given in the list
        /// </summary>
        /// <param name="offset">A LinkedListElement before which the new elements needs to be inserted</param>
        /// <param name="element">The element to be inserted</param>
        /// <returns>A reference to the newly created LinkedListElement</returns>

        private LinkedListNode<T> Add_Internal_Before(LinkedListNode<T> offset, T element)
        {
            if (offset == null)
                throw new Exception("Add_Internal: null is not a valid argument");

            LinkedListNode<T> Listelement = new LinkedListNode<T>(element);

            Listelement.Prev = offset.Prev;
            Listelement.Next = offset;

            if (offset.Prev != null) offset.Prev.Next = Listelement;
            offset.Prev = Listelement;

            if (offset == Head)
                Head = Listelement;

            LinkedList_Size++;

            return Listelement;
        }

        /// <summary>
        /// Private function which inserts a T element after the offset given in the list
        /// </summary>
        /// <param name="offset">The LinkedListElement after which we need to insert the new element</param>
        /// <param name="element">The element to be inserted</param>
        /// <returns>A reference to the newly created LinkListElement</returns>

        private LinkedListNode<T> Add_Internal_After(LinkedListNode<T> offset, T element)
        {
            if (offset == null)
                throw new Exception("Add_Internal: null is not a valid argument");

            LinkedListNode<T> Listelement = new LinkedListNode<T>(element);

            Listelement.Prev = offset;
            Listelement.Next = offset.Next;
            if (offset.Next != null) offset.Next.Prev = Listelement;
            offset.Next = Listelement;

            if (offset == Tail)
                Tail = Listelement;

            LinkedList_Size++;

            return Listelement;
        }

        /// <summary>
        /// Adds the specified element at the specified position in the list
        /// </summary>
        /// <param name="Index">The index at which to insert the element</param>
        /// <param name="element">The element of T to insert</param>
        /// <returns>True as per Java implementation</returns>

        public bool Add(int Index, T element)
        {
            if ((Index == 0) && (Head == null))
                AddFirst(element);
            else
                Add_Internal_Before(Get_Internal(Index), element);
            return true;
        }

        /// <summary>
        /// Adds the element to the end of the list
        /// </summary>
        /// <param name="element">The element of type T to insert</param>

        public void Add(T element)
        {
            if (Head == null)
                AddFirst(element);
            else
                Add_Internal_After(Tail, element);
        }

        /// <summary>
        /// Adds the element at the beginning of the list
        /// </summary>
        /// <param name="element">The element to add to the list</param>

        public void AddFirst(T element)
        {
            LinkedListNode<T> ListElement = new LinkedListNode<T>(element);
            if (Tail == null)
            {
                Tail = ListElement;
            }
            else
            {
                ListElement.Next = Head;
                Head.Prev = ListElement;
            }
            Head = ListElement;
            LinkedList_Size++;
        }

        /// <summary>
        /// Adds the given element to the end of the list
        /// </summary>
        /// <param name="element">Element to add to the list</param>

        public void AddLast(T element)
        {
            LinkedListNode<T> Listelement = new LinkedListNode<T>(element);
            if (Head == null)
            {
                Head = Listelement;
            }
            else
            {
                Listelement.Prev = Tail;
                Tail.Next = Listelement;
            }
            Tail = Listelement;
            LinkedList_Size++;
        }

        /// <summary>
        /// Private function which adds all the elements in the given collection to the list
        /// </summary>
        /// <param name="start">A LinkedListElement giving the starting point in the list</param>
        /// <param name="collection">Elements to add to the list</param>

        private void AddAll_Internal(LinkedListNode<T> start, T[] collection)
        {
            // The set of elements is inserted before start, but then needs to follow the
            // newly inserted first element.
            bool First = true;
            foreach (T element in collection)
            {
                if (Head == null)
                {
                    AddFirst(element);
                    start = Head;
                    First = false;
                }
                else
                {
                    if (First)
                    {
                        start = Add_Internal_Before(start, element);
                        First = false;
                    }
                    else
                        start = Add_Internal_After(start, element);
                }
            }
        }

        /// <summary>
        /// Adds all the elements in the collection to the end of the list
        /// </summary>
        /// <param name="collection">An array of T with all the elements to add</param>

        public void AddAll(T[] collection)
        {
            // Obtain the element at the given offset
            AddAll_Internal(Tail, collection);
        }

        /// <summary>
        /// Adds all the elements in the collection to the list from the end
        /// </summary>
        /// <param name="collection">An array of T with all the elements to add</param>

        public void AddAll(int index, T[] collection)
        {
            AddAll_Internal(Get_Internal(index), collection);
        }

        /// <summary>
        /// Empties the list by unlinking all elements.
        /// </summary>

        public void Clear()
        {
            LinkedListNode<T> Temp;

            while (Head != null)
            {
                Temp = Head;
                Head = Head.Next;

                Temp.Prev = null;
                Temp.Next = null;
            }

            Tail = null;
            LinkedList_Size = 0;
        }

        /// <summary>
        /// Returns a copy of the LinkedList containing all the elements.
        /// </summary>
        /// <returns>A LinkedList of the same type</returns>

        public LinkedList<T> Clone()
        {
            LinkedList<T> ClonedCopy = new LinkedList<T>();

            LinkedListNode<T> Iterator = Head;
            while (Iterator != null)
            {
                ClonedCopy.AddLast(Iterator.Data);
                Iterator = Iterator.Next;
            }
            return ClonedCopy;
        }

        // Contains
        // Returns true if the list contains the specified element

        public bool Contains(T needle)
        {
            LinkedListNode<T> Iterator = Head;
            while (Iterator != null)
            {
                // Check for null in the needle
                if ((needle == null)&&(Iterator.Data == null))
                  return true;

                // Check for null in the list
                if (Iterator.Data != null)
                    if (Iterator.Data.Equals(needle))
                        return true;

                // Not found, continue to the next entry
                Iterator = Iterator.Next;
            }
            return false;
        }

        /// <summary>
        /// Returns the number of elements in this list
        /// </summary>
        /// <returns>the number of elements in the list</returns>

        public int Size()
        {
            return LinkedList_Size;
        }

        /// <summary>
        /// An internal function which travels the list to find the specified index.
        /// The function travels forward/backward depending on whether the head or
        /// tail is closer to the specified index.
        /// </summary>
        /// <param name="Index">The position in the list to find.</param>
        /// <returns></returns>

        private LinkedListNode<T> Get_Internal(int Index)
        {
            if ((LinkedList_Size == 0) || (Index < 0) || (Index >= LinkedList_Size))
                throw new IndexOutOfRangeException("LinkedList<T> Invalid Index");

            LinkedListNode<T> iterator;
            int DistanceFromHead = Index;
            int DistanceFromTail = LinkedList_Size - Index -1;  

            if (DistanceFromHead < DistanceFromTail)
            {
                // We travel forward if the index is closer to the beginning
                iterator = Head;
                while (iterator != null && DistanceFromHead-- > 0)
                    iterator = iterator.Next;
            }
            else
            {
                // We travel backward if the index is closer to the end
                iterator = Tail;
                while (iterator != null && DistanceFromTail-- > 0)
                    iterator = iterator.Prev;
            }

            return iterator;
        }

        /// <summary>
        /// Returns the value of the specified element in the list
        /// </summary>
        /// <param name="index">The index item to return</param>
        /// <returns>The value of the element specified </returns>
        /// <throws>IndexOutOfBoundsException if the index is out of range (smaller than 0 or index >= size()</throws>

        public T Get(int index)
        {
            return Get_Internal(index).Data;
        }

        /// <summary>
        /// Returns the value stored at the head of the list
        /// </summary>
        /// <returns>The value stored at the head of the list</returns>

        public T GetFirst()
        {
            if (LinkedList_Size == 0)
                throw new IndexOutOfRangeException("LinkedList<T> Invalid Index");
            return Head.Data;
        }

        /// <summary>
        /// Returns the value stored at the tail of the list
        /// </summary>
        /// <returns>The value stored at the tail of the list</returns>

        public T GetLast()
        {
            if (LinkedList_Size == 0)
                throw new IndexOutOfRangeException("LinkedList<T> Invalid Index");
            return Tail.Data;
        }

        /// <summary>
        /// Search for the given element in the list and return the LinkedListNode
        /// </summary>
        /// <param name="element">Element to search for</param>
        /// <returns></returns>

        private LinkedListNode<T> IndexOf_Internal(T element)
        {
            int Index = 0;
            LinkedListNode<T> Iterator = Head;
            while (Iterator != null)
            {
                // Check for null in the needle
                if ((element == null) && (Iterator.Data == null))
                    return Iterator;

                // Check for null in the list
                if (Iterator.Data != null)
                    if (Iterator.Data.Equals(element))
                        return Iterator;

                Index++;
                Iterator = Iterator.Next;
            }
            return null;
        }

        /// <summary>
        /// This routine searches the linked list for the first occurance of the specified element
        /// </summary>
        /// <param name="element">The value to look for, null is also possible</param>
        /// <returns>The index of the item searched, or -1 if not found</returns>

        public int IndexOf(T element)
        {
            int Index = 0;
            LinkedListNode<T> Iterator = Head;
            while (Iterator != null)
            {
                // Check for null in the needle
                if ((element == null) && (Iterator.Data == null))
                    return Index;

                // Check for null in the list
                if (Iterator.Data != null)
                    if (Iterator.Data.Equals(element))
                        return Index;

                Index++;
                Iterator = Iterator.Next;
            }
            return -1;
        }

        /// <summary>
        /// Returns the last occurance of the specified element in the list
        /// </summary>
        /// <param name="element">The value to search for</param>
        /// <returns>The index of the element, or -1 if not found</returns>

        public int LastIndexOf(T element)
        {
            int Index = LinkedList_Size;
            LinkedListNode<T> Iterator = Tail;
            while (Iterator != null)
            {
                Index--;

                // Check for null in the element
                if ((element == null) && (Iterator.Data == null))
                    return Index;

                // Check for null in the list before checking the content
                if (Iterator.Data != null)
                    if (Iterator.Data.Equals(element))
                        return Index;

                Iterator = Iterator.Prev;
            }
            return -1;
        }

        /// <summary>
        /// An internal function which unlinks a specified link in the list chain.
        /// </summary>
        /// <param name="element">A reference to the list item to unlink</param>

        public void Remove_Internal(LinkedListNode<T> element)
        {
            if (element == null)
                throw new Exception("LinkedListNode<T> null is not a valid argument");

            if (element == Head)
                Head = element.Next;

            if (element == Tail)
                Tail = element.Prev;

            if (element.Prev != null)
                element.Prev.Next = element.Next;

            if (element.Next != null)
                element.Next.Prev = element.Prev;

            LinkedList_Size--;
        }

        /// <summary>
        /// This function removes the specified index item from the list
        /// </summary>
        /// <param name="Index"></param>
        /// <throws>IndexOutOfRangeException if an invalid index is given</throws>
        /// <returns></returns>

        public T Remove(int Index)
        {
            LinkedListNode<T> Element = Get_Internal(Index);

            T Data = Element.Data;

            Remove_Internal(Element);

            return Data;
        }

        /// <summary>
        /// Searches the list for the first occurance of the specified element, and removes it.
        /// </summary>
        /// <param name="element">Element to remove</param>
        /// <returns>True if the element was found and removed, False if not found</returns>

        public bool Remove(T element)
        {
            LinkedListNode<T> Node = IndexOf_Internal(element);

            // Find the element offset
            if (Node != null)
            {
                // This is bad -- we walk the list twice -- need to optimize
                Remove_Internal(Node);
                return true;
            }

            return false;
        }

        /// <summary>
        /// This routine removes the first element from the list
        /// </summary>
        /// <returns>The value of the element removed</returns>
        /// <throws>IndexOutofRangException if the list is empty</throws>

        public T RemoveFirst()
        {
            if (LinkedList_Size == 0)
                throw new IndexOutOfRangeException("LinkedList<T> Empty List");

            T Data = Head.Data;

            Remove_Internal(Head);

            return Data;
        }

        /// <summary>
        /// Remove the last element of the list
        /// </summary>
        /// <returns>The value of the element removed</returns>
        /// <throws>IndexOutofRangException if the list is empty</throws>

        public T RemoveLast()
        {
            if (LinkedList_Size == 0)
                throw new IndexOutOfRangeException("LinkedList<T> Empty List");

            T Data = Tail.Data;

            Remove_Internal(Tail);

            return Data;
        }

        /// <summary>
        /// This routine inserts the given element at the given index
        /// </summary>
        /// <param name="Index">The index to insert the element at</param>
        /// <param name="element">The element to insert</param>
        /// <returns></returns>

        public T Set(int Index, T element)
        {
            LinkedListNode<T> OldListEntry = Get_Internal(Index);

            // Keep a pointer to the old data object
            T Temp = OldListEntry.Data;

            // Swap it with the new data object
            OldListEntry.Data = element;

            // And return the old one
            return Temp;
        }

        /// <summary>
        /// Returns an array containing all the elements in the list in the head-tail order
        /// </summary>
        /// <returns>An array of T[] containing all the elements in the list</returns>

        public T[] ToArray()
        {
            LinkedListNode<T> iterator = Head;
            T[] DataArray = new T[LinkedList_Size];
            int Index = 0;

            while (iterator != null)
            {
                DataArray[Index++] = iterator.Data;
                iterator = iterator.Next;
            }

            return DataArray;
        }

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

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

        /// <summary>
        /// The LinkedListEnumerator is an nested class implementing the IENumerator interface. Making it
        /// possible to call foreach() on the list.
        /// </summary>

        class LinkedListEnumerator : IEnumerator<T>
        {
            LinkedListNode<T> start;
            LinkedListNode<T> current;

            public LinkedListEnumerator(LinkedList<T> list)
            {
                start = list.Head;
                current = null;
            }
            public bool MoveNext()
            {
                if (current == null) current = start;
                else current = current.Next;
                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; }
        }

    }

}

LinkedList_NUnit.cs

using System;
using System.Text;
using NUnit.Framework;

namespace LinkedListJavaStyle
{
    /// <summary>
    /// LinkedList_NUnit is a class implementing a set of unit tests for each of the methods supported by the LinkedList class
    /// </summary>

    [TestFixture]
    public class LinkedList_NUnit
    {

        [TestX]
        public void TestLinkedList_add()
        {
            LinkedList<string> Test = new LinkedList<string>();
            Test.Add("Hello World");
            Test.Add("The world today");
            Assert.AreEqual(2, Test.Size());
        }

        [Test]
        public void TestLinkedList_Add_AtIndex()
        {
            LinkedList<string> Test = new LinkedList<string>();
            Test.Add("Hello World");
            Test.Add("The world today");
            Test.Add("Boom Boom");
            Test.Add(2, "Much Wiser");
            Assert.AreEqual(4, Test.Size());
            string Value = Test.Get(2);
            Assert.AreEqual("Much Wiser", Value);
        }

        [Test]
        public void TestLinkedList_Add_AtFirst()
        {
            LinkedList<string> Test = new LinkedList<string>();
            Test.Add("Hello World");
            Test.Add("The world today");
            Test.AddFirst("Much Wiser");
            Assert.AreEqual(3, Test.Size());
            string Value = Test.Get(0);
            Assert.AreEqual("Much Wiser", Value);
        }

        [Test]
        public void TestLinkedList_Add_AtLast()
        {
            LinkedList<string> Test = new LinkedList<string>();
            Test.Add("Hello World");
            Test.Add("The world today");
            Test.AddLast("Much Wiser");
            Assert.AreEqual(3, Test.Size());
            string Value = Test.Get(2);
            Assert.AreEqual("Much Wiser", Value);
        }

        [Test]
        public void TestLinkedList_Add_All()
        {
            LinkedList<string> Test = new LinkedList<string>();
            string[] Input = { "Hello World", "The World Today", "Much Wiser" };
            Test.AddAll(Input);
            Assert.AreEqual(3, Test.Size());
            string Value = Test.Get(1);
            Assert.AreEqual("The World Today", Value);
        }

        [Test]
        public void TestLinkedList_Add_AllFromIndex()
        {
            LinkedList<string> Test = new LinkedList<string>();
            string[] Input = { "Hello World", "The World Today", "Much Wiser" };
            string[] Input2 = { "Monty Python", "Flying Circus" };
            Test.AddAll(Input);
            Assert.AreEqual(3, Test.Size());
            Test.AddAll(1, Input2);
            string Value = Test.Get(2);
            Assert.AreEqual("Flying Circus", Value);
        }

        [Test]
        public void TestLinkedList_Clear()
        {
            LinkedList<string> Test = new LinkedList<string>();
            string[] Input = { "Hello World", "The World Today", "Much Wiser" };
            Test.AddAll(Input);
            Test.Clear();
            Assert.AreEqual(0, Test.Size());
        }

        [Test]
        public void TestLinkedList_Clone()
        {
            LinkedList<string> Test = new LinkedList<string>();
            LinkedList<string> Test2;
            string[] Input = { "Hello World", "The World Today", "Much Wiser" };
            Test.AddAll(Input);
            Test2 = Test.Clone();
            Test.Clear();
            Assert.AreEqual(3, Test2.Size());
            string Value = Test2.Get(1);
            Assert.AreEqual("The World Today", Value);
        }

        [Test]
        public void TestLinkedList_Contains()
        {
            LinkedList<string> Test = new LinkedList<string>();
            string[] Input = { "Hello World", "The World Today", null, "Much Wiser" };
            Test.AddAll(Input);
            Assert.IsTrue(Test.Contains("Hello World"));
            Assert.IsFalse(Test.Contains("Botany Bay"));
            Assert.IsTrue(Test.Contains(null));
        }

        [Test]
        public void TestLinkedList_Get()
        {
            LinkedList<string> Test = new LinkedList<string>();
            string[] Input = { "Hello World", "The World Today", "Much Wiser" };
            Test.AddAll(Input);
            string Value = Test.Get(2);
            Assert.AreEqual("Much Wiser", Value);
            Assert.
        }

        [Test]
        public void TestLinkedList_GetFirst()
        {
            LinkedList<string> Test = new LinkedList<string>();
            string[] Input = { "Hello World", "The World Today", "Much Wiser" };
            Test.AddAll(Input);
            string Value = Test.GetFirst();
            Assert.AreEqual("Hello World", Value);
        }

        [Test]
        public void TestLinkedList_GetLast()
        {
            LinkedList<string> Test = new LinkedList<string>();
            string[] Input = { "Hello World", "The World Today", "Much Wiser" };
            Test.AddAll(Input);
            string Value = Test.GetLast();
            Assert.AreEqual("Much Wiser", Value);
        }

        [Test]
        public void TestLinkedList_IndexOf()
        {
            LinkedList<string> Test = new LinkedList<string>();
            string[] Input = { "Hello World", "The World Today", null, "Much Wiser" };
            Test.AddAll(Input);
            int IndexValue = Test.IndexOf("The World Today");
            Assert.AreEqual(1, IndexValue);
            int IndexValue2 = Test.IndexOf("My Day In the Sun");
            Assert.AreEqual(-1, IndexValue2);
            int IndexValue3 = Test.IndexOf(null);
            Assert.AreEqual(2, IndexValue3);
        }

        [Test]
        public void TestLinkedList_LastIndexOf()
        {
            LinkedList<string> Test = new LinkedList<string>();
            string[] Input = { "Hello World", "The World Today", null, "Hello World", null };
            Test.AddAll(Input);
            int IndexValue = Test.LastIndexOf("Hello World");
            Assert.AreEqual(3, IndexValue);
            int IndexValue2 = Test.LastIndexOf("My Day In the Sun");
            Assert.AreEqual(-1, IndexValue2);
            int IndexValue3 = Test.LastIndexOf(null);
            Assert.AreEqual(4, IndexValue3);
        }

        [Test]
        public void TestLinkedList_listIterator()
        {
            LinkedList<string> Test = new LinkedList<string>();
            // The array is empty, and we should never enter this part
            foreach (string token in Test)
                Assert.Fail("Entered empty iterator");

            string[] Input = { "Hello World", "The World Today", "Hello World" };

            Test.AddAll(Input);

            // Match the contents against the string[]
            int offset = 0;
            foreach (string token in Test)
                Assert.AreEqual(token, Input[offset++]);
        }

        [Test]
        public void TestLinkedList_remove()
        {
            LinkedList<string> Test = new LinkedList<string>();
            string[] Input = { "Hello World", "The World Today", "Its going to be a fine day" };
            Test.AddAll(Input);
            Test.Remove(1);
            // There are only 2 elements left
            Assert.AreEqual(Test.Size(), 2);
            // Before the removal this was Position 2
            int IndexValue1 = Test.IndexOf("Its going to be a fine day");
            Assert.AreEqual(IndexValue1, 1);
        }

        [Test]
        public void TestLinkedList_RemoveObject()
        {
            LinkedList<string> Test = new LinkedList<string>();
            string[] Input = { "Hello World", "The World Today", "Its going to be a fine day" };
            Test.AddAll(Input);
            Assert.AreEqual(Test.Remove("Its going to be a fine day"), true);
            // There are only 2 elements left
            Assert.AreEqual(Test.Size(), 2);
            // We should not be able to find this element
            Assert.AreEqual(Test.IndexOf("Its going to be a fine day"), -1);
        }

        [Test]
        public void TestLinkedList_removeFirst()
        {
            LinkedList<string> Test = new LinkedList<string>();
            string[] Input = { "Hello World", "The World Today", "Its going to be a fine day" };
            Test.AddAll(Input);
            Test.RemoveFirst();
            // There are only 2 elements left
            Assert.AreEqual(Test.Size(), 2);
            // Before the removal this was Position 1
            int IndexValue1 = Test.IndexOf("The World Today");
            Assert.AreEqual(IndexValue1, 0);
        }

        [Test]
        public void TestLinkedList_removeLast()
        {
            LinkedList<string> Test = new LinkedList<string>();
            string[] Input = { "Hello World", "The World Today", "Its going to be a fine day" };
            Test.AddAll(Input);

            // We should not be able to find this now
            int IndexValue1 = Test.IndexOf("Its going to be a fine day");
            Assert.AreEqual(IndexValue1, 2);

            // Remove the last entry
            Test.RemoveLast();

            // There are only 2 elements left
            Assert.AreEqual(Test.Size(), 2);

            // We should not be able to find this now
            int IndexValue2 = Test.IndexOf("Its going to be a fine day");
            Assert.AreEqual(IndexValue2, -1);
        }

        [Test]
        public void TestLinkedList_Set()
        {
            LinkedList<string> Test = new LinkedList<string>();
            string[] Input = { "Hello World", "The World Today", "Its going to be a fine day" };
            Test.AddAll(Input);

            // Replace position #1 with a new object
            string OldValue = Test.Set(1, "Sunday Sports");
            Assert.AreEqual(OldValue, "The World Today");

            int IndexValue2 = Test.IndexOf("Sunday Sports");
            Assert.AreEqual(IndexValue2, 1);
        }

        [Test]
        public void TestLinkedList_ToArray()
        {
            LinkedList<string> Test = new LinkedList<string>();
            string[] Input = { "Hello World", "The World Today", "Its going to be a fine day", null };
            Test.AddAll(Input);

            string[] Copy = Test.ToArray();

            int Index = 0;
            foreach (string element in Input)
                Assert.AreEqual(element, Copy[Index++]);
        }

    }

}

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

If you don’t know in advance how many elements you are going to store a linked list is often a good solution. But what is a linked list anyway? I

In a linked list every element is linked to the next element in the list. If you would like to add a new element, you just allocate the memory for the new element and add it to the chain. So at the price of a little overhead (the need to keep links) you are prepared for situations that might grow from just 1 or 2 items to huge numbers of elements.

A common alternative is to allocate an array and allow it to grow when it reaches maximum capacity. This incurs a processing penalty as new memory needs to be allocated and the old array is copied to the new array.

For the linked list the penalty comes in access speed. In an array you can immediately access every element through my_array[1], my_array[1000] etc. In a linked list you have to start at the top and step through the whole list until the element is found. One optimization you can make here is to keep a counter of elements. If you know that the element you are looking for is closer to the end you could start at the end of the list, and count backwards.

Another benefit of linked lists is that it is possible to remove elements, something that is very hard to do in arrays. An array with many empty elements becomes wasteful and would require repacking or shrinking.

The following code implements a simple linked list using C# generics.

First we need to define the link elements in C# we use a class for this, not a struct. The reason being that classes in C# are passed by reference. If you make a copy of a reference, just the reference is copied, not the original item (which is just like using pointers in C and C++) If we were to use a struct each action would involve copying the whole item as structs are passed by value.

    class LinkedListElement<T>
    {
        public T Data;
        public LinkedListElement<T> Prev;
        public LinkedListElement<T> Next;

        public LinkedListElement(T Data)
        {
            this.Data = Data;
        }
    }

As you can see from the above definition we will be using a double-linked list: we keep a reference to both the previous and next item in the list. The benefit of this is that is it possible to travel through the list both in directions. In a single linked list, we would only have a reference to the next item, but not to the previous one. It also makes it easier to remove elements from the list.

    class LinkedList<T>
    {
        public LinkedListElement<T> Head;
        public LinkedListElement<T> Tail;

        public LinkedList()
        {
            Head = null;
            Tail = null;
        }
    }

In the double linked list we keep a reference to both the Head and Tail of the list. In an empty list, both the Head and Tail are NULL. If the list contains only one element, both Head and Tail point to the same element. For the Head element, the previous element is always NULL. For the Tail element the next element is always NULL.

        public void Add(T element)
        {
            LinkedListElement<T> Listelement = new LinkedListElement<T>(element);
            if (Head == null)
            {
                Head = Listelement;
            }
            else
            {
                Listelement.Prev = Tail;
                Tail.Next = Listelement;
            }
            Tail = Listelement;
        }

In adding to the list we need to check if the list is empty, if it is, the new element becomes the head.Otherwise we will add the new element to the end of the tail.

        public void Remove(LinkedListElement<T> element)
        {
            if (element == null)
                throw new Exception("LinkedListElement<T> null is not a valid argument");

            if (element == Head)
                Head = element.Next;
            if (element == Tail)
                Tail = element.Prev;

            if (element.Prev != null)
            {
                LinkedListElement<T> prev = element.Prev;
                prev.Next = element.Next;
            }
            if (element.Next != null)
            {
                LinkedListElement<T> next = element.Next;
                next.Prev = element.Prev;
            }
        }

Removing an element from the list involves fusing the previous element and next element together. And of course we need to check if it the element removed is the head or tail element.

The last basic action of using a list is to find if an element is stored in the list.

        public LinkedListElement<T> Find(T needle)
        {
            return Find(needle, Head);
        }

        public LinkedListElement<T> Find(T needle, LinkedListElement<T> start)
        {
            LinkedListElement<T> iterator = start;
            while (iterator != null)
            {
                if (iterator.Data.Equals(needle)) return iterator;
                iterator = iterator.Next;
            }
            return null;
        }

A simple iterator loops through the list comparing the linked list element to the one you are looking for, starting from the head of the list.

The full code of the linked list implementation is listed below. There is still much that it can be improved upon. C# provides a standard iterator mechanism, which is easy to implement and would make it possible to use our linked list in a forearch loop. That would also remove the need to expose so much of the classes internals to the outside world. A better implementation would hide the internal use of LinkedListElement completely.

In my next post I will show an implementation of Java inspired LinkedList class in C# which improves on the above problems.

using System;

namespace LinkedList_Simple
{

    class LinkedListElement<T>
    {
        public T Data;
        public LinkedListElement<T> Prev;
        public LinkedListElement<T> Next;

        public LinkedListElement(T Data)
        {
            this.Data = Data;
        }
    }

    class LinkedList<T>
    {

        public LinkedListElement<T> Head;
        public LinkedListElement<T> Tail;

        public LinkedList()
        {
            Head = null;
            Tail = null;
        }

        public void Add(T element)
        {
            LinkedListElement<T> Listelement = new LinkedListElement<T>(element);
            if (Head == null)
            {
                Head = Listelement;
            }
            else
            {
                Listelement.Prev = Tail;
                Tail.Next = Listelement;
            }
            Tail = Listelement;
        }

        public LinkedListElement<T> Next(LinkedListElement<T> element)
        {
            if (element == null)
                throw new Exception("LinkedListElement<T> null is not a valid argument");
            return element.Next;
        }

        public LinkedListElement<T> Prev(LinkedListElement<T> element)
        {
            if (element == null)
                throw new Exception("LinkedListElement<T> null is not a valid argument");
            return element.Prev;
        }

        public void Remove(LinkedListElement<T> element)
        {
            if (element == null)
                throw new Exception("LinkedListElement<T> null is not a valid argument");

            if (element == Head)
                Head = element.Next;
            if (element == Tail)
                Tail = element.Prev;

            if (element.Prev != null)
            {
                LinkedListElement<T> prev = element.Prev;
                prev.Next = element.Next;
            }
            if (element.Next != null)
            {
                LinkedListElement<T> next = element.Next;
                next.Prev = element.Prev;
            }
        }

        public LinkedListElement<T> Find(T needle)
        {
            return Find(needle, Head);
        }

        public LinkedListElement<T> Find(T needle, LinkedListElement<T> start)
        {
            LinkedListElement<T> iterator = start;
            while (iterator != null)
            {
                if (iterator.Data.Equals(needle)) return iterator;
                iterator = iterator.Next;
            }
            return null;
        }

    }

    class MainClass
    {
        public static void Main(string[] args)
        {
            LinkedList<string> myList = new LinkedList<string>();
            myList.Add("Hello World");
            myList.Add("Good day to you");
            myList.Add("Once upon a time in the west");

            LinkedListElement<string> search_it = myList.Find("Good day to you");

            if (search_it != null)
            {
                Console.WriteLine("Found: {0}", search_it.Data);
                myList.Remove(search_it);
            }
            else
                Console.WriteLine("Not found!");

            // Print the contents of the entire list
            LinkedListElement<string> print_it = myList.Head;

            int Lp = 0;
            while (print_it != null)
            {
                Console.WriteLine("{0} {1}", Lp++, print_it.Data);
                print_it = myList.Next(print_it);
            }

        }
    }

}

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.