Justins Fat Tire

C# convert string array to integer (or something other kind of data type) array

2011-11-22T09:48:00.001-07:00

Many times in coding you are dealing with transforming data from one type to another. I often find myself creating integers, longs, etc from strings. Especially in .net for some reason. I got tired of writing tons of code to handle this. .Net gives you a great way to convert an array from one type to another.

Currently I would always end up writing a for loop iterating through the array and doing a manual copy. It would look something like this:

string[] someStringValues;

int[] someIntValues = new int[someStringValues.Length];

for( int i = 0; i < someStringValues.Length; i++ )
{
   someIntValues[i] = int.Parse( someIntValues[i] );
}

Not horrible code, but there is a more succinct way of doing it!

string[] someStringValues;

int[] someIntValues = Array.ConvertAll<string, int>( someStringValues, int.Parse );

We have now moved all that code into 1 line. With some more magic we can also move this into a generic templated solution and you could theoretically change any array type into another type with the appropriate converter. This could apply not only to basic data types but complex classes with an associated converter.

C# Simple Binary Tree

2011-11-18T13:45:00.001-07:00

Today I'm getting a bit into data structures. Recently I've found a need to store a large amount of records (16 million) in memory as a sort of cache. I tried using databases, etc, but it was all too slow. I needed super fast access times, well under a millisecond to speed up a large application with many data look ups. I tried a linked list but while the insert times were great the look ups again were too slow. I finally settled on a binary tree. Building the tree is slow, several minutes, but this data doesn't change and gives me super fast look up times, around .005 ms. To achieve this I wrote a very simple binary tree class.

It uses a node that is fit for my purposes. To make this class even better I would implement in generics with a node class that has to implement IComparable. This way you can make a binary tree for any type of class that can be compared. For now I'm hard coding the key/values for my specific needs. See the rather large code block below. I will add a zip file with the code as well.

using System;
using System.Collections;

namespace BinaryTree
{
   
    /// <summary>
    /// A very basic Binary Search Tree. Not generalized, stores
    /// name/value pairs in the tree nodes. name is the node key.
    /// The advantage of a binary tree is its fast insert and lookup
    /// characteristics. This version does not deal with tree balancing.
    /// </summary>
    public class TreeNode
    {
        #region Fields

        private string _name;
        
        private int[] _codes;
        
        public TreeNode Left, Right;

        #endregion

        #region Properties

        /// <summary>
        /// Gets or sets the name.
        /// </summary>
        /// <value>
        /// The name.
        /// </value>
        public string Name
        {
            get { return _name; }
            set { _name = value; }
        }

        /// <summary>
        /// Gets or sets the codes.
        /// </summary>
        /// <value>
        /// The codes.
        /// </value>
        public int[] Codes
        {
            get { return _codes; }
            set { _codes = value; }
        }
        
        #endregion

        /// <summary>
        /// Initializes a new instance of the <see cref="TreeNode"/> class.
        /// </summary>
        /// <param name="name">The name.</param>
        /// <param name="_codes">The _codes.</param>
        public TreeNode( string name, int[] codes )
        {
            _name = name;
            _codes = codes;
            Left = null;
            Right = null;
        }
    }

    /// <summary>
    /// A basic binary tree with a string, int[] node.  string is the key, int[] is the value
    /// </summary>
    public class BinaryTree
    {
        #region Fields

        // Points to the _root of the tree
        private TreeNode _root;

        // a count of nodes in the tree, duh!
        private int _count = 0;

        #endregion

        #region Properties

        /// <summary>
        /// Returns the number of nodes in the tree
        /// </summary>
        /// <returns>Number of nodes in the tree</returns>
        public int Count
        {
            get { return _count; }
        }

        #endregion

        /// <summary>
        /// Initializes a new instance of the <see cref="BinaryTree"/> class.
        /// </summary>
        public BinaryTree()
        {
            _root = null;
            _count = 0;
        }

        #region Public Methods

        /// <summary>
        /// Clear the binary tree.
        /// </summary>
        public void Clear()
        {
            this.KillTree( ref _root );
            _count = 0;
        }       

        /// <summary>
        /// Find name in tree. Return a reference to the node
        /// if symbol found else return null to indicate failure.
        /// </summary>
        /// <param name="name">Name of node to locate</param>
        /// <returns>Returns null if it fails to find the node, else returns reference to node</returns>
        public TreeNode FindSymbol( string name )
        {
            TreeNode np = _root;

            int cmp;
            
            while( np != null )
            {
                cmp = String.CompareOrdinal( name, np.Name );

                if( cmp == 0 )   // found !
                {
                    return np;
                }

                if( cmp < 0 )
                {
                    np = np.Left;
                }
                else
                {
                    np = np.Right;
                }
            }
            return null;  // Return null to indicate failure to find name
        }

        /// <summary>
        /// Recursively locates an empty slot in the binary tree and inserts the node
        /// </summary>
        /// <param name="node">The node.</param>
        /// <param name="tree">The tree.</param>
        private void Add( TreeNode node, ref TreeNode tree )
        {
            if( tree == null )
            {
                tree = node;
            }
            else
            {
                // If we find a node with the same name then it's 
                // a duplicate and we can't continue
                int comparison = String.CompareOrdinal( node.Name, tree.Name );

                if( comparison == 0 )
                {
                    throw new Exception();
                }

                if( comparison < 0 )
                {
                    Add( node, ref tree.Left );
                }
                else
                {
                    Add( node, ref tree.Right );
                }
            }
        }

        /// <summary>
        /// Add a symbol to the tree if it's a new one. Returns reference to the new
        /// node if a new node inserted, else returns null to indicate node already present.
        /// </summary>
        /// <param name="name">Name of node to add to tree</param>
        /// <param name="d">Value of node</param>
        /// <returns> Returns reference to the new node is the node was inserted.
        /// If a duplicate node (same name was located then returns null</returns>
        public TreeNode Insert( string name, int[] codes )
        {
            TreeNode node = new TreeNode( name, codes );
            try
            {
                if( _root == null )
                {
                    _root = node;
                }
                else
                {
                    Add( node, ref _root );
                }
                
                _count++;
                
                return node;

            }
            catch( Exception )
            {
                return null;
            }
        }

        // Searches for a node with name key, name. If found it returns a reference
        // to the node and to thenodes parent. Else returns null.
        private TreeNode FindParent( string name, ref TreeNode parent )
        {
            TreeNode np = _root;
            
            parent = null;
            
            int cmp;

            while( np != null )
            {
                cmp = String.Compare( name, np.Name );
                if( cmp == 0 )   // found !
                    return np;

                if( cmp < 0 )
                {
                    parent = np;
                    np = np.Left;
                }
                else
                {
                    parent = np;
                    np = np.Right;
                }
            }

            return null;  // Return null to indicate failure to find name

        }

        /// <summary>
        /// Find the next ordinal node starting at node startNode.
        /// Due to the structure of a binary search tree, the
        /// successor node is simply the left most node on the right branch.
        /// </summary>
        /// <param name="startNode">Name key to use for searching</param>
        /// <param name="parent">Returns the parent node if search successful</param>
        /// <returns>Returns a reference to the node if successful, else null</returns>
        public TreeNode FindSuccessor( TreeNode startNode, ref TreeNode parent )
        {
            parent = startNode;
            
            // Look for the left-most node on the right side
            startNode = startNode.Right;
            
            while( startNode.Left != null )
            {
                parent = startNode;
                startNode = startNode.Left;
            }

            return startNode;
        }

        /// <summary>
        /// Delete a given node. This is the more complex method in the binary search
        /// class. The method considers three senarios, 1) the deleted node has no
        /// children; 2) the deleted node as one child; 3) the deleted node has two
        /// children. Case one and two are relatively simple to handle, the only
        /// unusual considerations are when the node is the _root node. Case 3) is
        /// much more complicated. It requires the location of the successor node.
        /// The node to be deleted is then replaced by the sucessor node and the
        /// successor node itself deleted. Throws an exception if the method fails
        /// to locate the node for deletion.
        /// </summary>
        /// <param name="key">Name key of node to delete</param>
        public void Delete( string key )
        {
            TreeNode parent = null;

            // First find the node to delete and its parent
            TreeNode nodeToDelete = FindParent( key, ref parent );
            
            if( nodeToDelete == null )
            {
                throw new Exception( "Unable to delete node: " + key.ToString() );  // can't find node, then say so 
            }

            // Three cases to consider, leaf, one child, two children

            // If it is a simple leaf then just null what the parent is pointing to
            if( ( nodeToDelete.Left == null ) && ( nodeToDelete.Right == null ) )
            {
                if( parent == null )
                {
                    _root = null;
                    return;
                }

                // find out whether left or right is associated 
                // with the parent and null as appropriate
                if( parent.Left == nodeToDelete )
                {
                    parent.Left = null;
                }
                else
                {
                    parent.Right = null;
                }

                _count--;
                return;
            }

            // One of the children is null, in this case
            // delete the node and move child up
            if( nodeToDelete.Left == null )
            {
                // Special case if we're at the _root
                if( parent == null )
                {
                    _root = nodeToDelete.Right;
                    return;
                }

                // Identify the child and point the parent at the child
                if( parent.Left == nodeToDelete )
                {
                    parent.Right = nodeToDelete.Right;
                }
                else
                {
                    parent.Left = nodeToDelete.Right;
                }

                // Clean up the deleted node
                nodeToDelete = null; 
                _count--;
                return;

            }

            // One of the children is null, in this case
            // delete the node and move child up
            if( nodeToDelete.Right == null )
            {
                // Special case if we're at the _root            
                if( parent == null )
                {
                    _root = nodeToDelete.Left;
                    return;
                }

                // Identify the child and point the parent at the child
                if( parent.Left == nodeToDelete )
                {
                    parent.Left = nodeToDelete.Left;
                }
                else
                {
                    parent.Right = nodeToDelete.Left;
                }

                // Clean up the deleted node
                nodeToDelete = null; 
                _count--;
                return;

            }

            // Both children have nodes, therefore find the successor, 
            // replace deleted node with successor and remove successor
            // The parent argument becomes the parent of the successor
            TreeNode successor = FindSuccessor( nodeToDelete, ref parent );

            // Make a copy of the successor node
            TreeNode tmp = new TreeNode( successor.Name, successor.Codes );

            // Find out which side the successor parent is pointing to the
            // successor and remove the successor
            if( parent.Left == successor )
            {
                parent.Left = null;
            }
            else
            {
                parent.Right = null;
            }

            // Copy over the successor values to the deleted node position
            nodeToDelete.Name = tmp.Name;
            nodeToDelete.Codes = tmp.Codes;
            _count--;
        }

        /// <summary>
        /// Return the tree depicted as a simple string, useful for debugging, eg
        /// 50(40(30(20, 35), 45(44, 46)), 60)
        /// </summary>
        /// <returns>Returns the tree</returns>
        public string DrawTree()
        {
            return DrawNode( _root );
        }

        /// <summary>
        /// Returns a <see cref="System.String"/> that represents this instance.
        /// </summary>
        /// <returns>
        /// A <see cref="System.String"/> that represents this instance.
        /// </returns>
        public override string ToString()
        {
            return this.DrawTree();
        }

        #endregion

        #region Private Methods

        // Recursive destruction of binary search tree, called by method clear
        // and destroy. Can be used to kill a sub-tree of a larger tree.
        // This is a hanger on from its Delphi origins, it might be dispensable
        // given the garbage collection abilities of .NET
        private void KillTree( ref TreeNode p )
        {
            if( p != null )
            {
                KillTree( ref p.Left );

                KillTree( ref p.Right );

                p = null;

            }
        }

        /// <summary>
        /// Draws the node.
        /// </summary>
        /// <param name="node">The node.</param>
        /// <returns></returns>
        private string DrawNode( TreeNode node )
        {
            if( node == null )
            {
                return "empty";
            }

            if( node.Left == null &&
                node.Right == null )
            {
                return node.Name;
            }
            if( node.Left != null &&
                node.Right == null )
            {
                return String.Format( "{0}({1}, )", node.Name, DrawNode( node.Left ) );
            }
            if( node.Right != null &&
                node.Left == null )
            {
                return String.Format( "{0}(_,{1})", node.Name, DrawNode( node.Right ) );

            }

            return String.Format( "{0}({1},{2})", node.Name, DrawNode( node.Left ), DrawNode( node.Right ) );

        }

        #endregion

    }
}

C# create a new process

2011-09-30T08:07:00.000-07:00

Once in a while I find myself needing to spawn a process in C#. The .net framework has some built in functionality to do this. It's fairly trivial to just spawn a process and let it run. .NET however allows us many options to customize the look and feel as well as the error output of the spawned process. The example below simply fires up notepad with a default document. You can customize this heavily as mentioned and not show windows, etc.

You can read all about is on MSDN.

// create and setup the process object
chartProcess = new Process();
chartProcess.StartInfo.FileName = "notepad.exe";

// this is all optional setup

// pass in any command line arguments if desired
chartProcess.StartInfo.Arguments = "test.txt";

//
chartProcess.StartInfo.UseShellExecute = false;

// this determines if we show the actual command or form window
chartProcess.StartInfo.CreateNoWindow = false;

// this lets us handle an event when the process we start stops
chartProcess.EnableRaisingEvents = true;
chartProcess.Exited += new EventHandler( chartProcess_Exited );

// start the process
chartProcess.Start();

C# Parallel.For

2011-08-30T09:31:00.001-07:00

With the advent of C# 4.0 you can now write code to more efficiently use multiple core machines. I will show a trivial example on how to do this. This code reads through a directory and lists all the files. Now while the example itself isn't that complicated I will show some timings and benefits on my Intel duo core 2 machine. Running on even more cores would show an even bigger result. This kind of computing really shines when you're dealing with large amounts of data or very intensive computations. This test sums up 10 million random integers.



using System.Threading.Tasks;

static void Main( string[] args )
{
      int[] values = new int[10000000];

      Random r = new Random( DateTime.Now.Millisecond );

      double sum = 0;

      for( int i = 0; i < values.Length; i++ )
      {
          values[i] = r.Next( 0, 10 );
      }

      DateTime start = DateTime.Now;
      DateTime end;

      // run the test in parallel
      Parallel.For( 0, values.Length, delegate( int i )
      {
          sum += values[i];
      } );

      end = DateTime.Now;

      TimeSpan t = end - start;

      Console.WriteLine( "Parrallel For time is: " + t.TotalMilliseconds + ", sum is: " + sum );

      start = DateTime.Now;

      // run the test in sequential
      for( int i = 0; i < values.Length; i++ )
      {
          values[i] = r.Next( 0, 10 );
      }

      end = DateTime.Now;

      t = end - start;

      Console.WriteLine();
      Console.WriteLine( "Regular For time is: " + t.TotalMilliseconds + ", sum is: " + sum );

      Console.ReadKey();
}

The Parallel.For looks almost exactly like the regular for. The main difference is you have to add in the delegate(int) at the end. This is used when the compiler creates the different threads to use on the various CPUs. A more detailed explanation can be found here:

MSDN Link

Now onto the results!

After many runs the parallel code ran anywhere from almost twice as fast to 100 ms faster. Now this is just a random summation of integers. Even more computationally complex tasks should see even more benefit

Some results:

C# create MD5 hash from a string

2011-08-23T10:27:00.000-07:00

A common task when dealing with sensitive data is to create a hash of it. MD5 is used quite often especially when dealing with password, etc. I will leave the discussion of collisions, etc to others and just show a function that will return an array of bytes that is the result of hashing the input string. This function calls for an Encoding object to be passed in since you never know what encoding you will be using. But you could easily hard code the encoding if you know that will never change.

using System.Security.Cryptography;

/// <summary>
/// Hashes the string.
/// </summary>
/// <param name="valueToHash">The value to hash.</param>
/// <param name="textEncoding">The text encoding.</param>
/// <returns></returns>
private byte[] HashString( String valueToHash, Encoding textEncoding )
{
   byte[] result;

   using( MD5 md5 = MD5.Create() )
   {
      byte[] inputBytes = textEncoding.GetBytes( valueToHash );
      result = md5.ComputeHash( inputBytes );
   }

   return result;

}

C# get the number of days in a month

2011-08-18T08:35:00.000-07:00

Ok this isn't the longest blog post, but it contains a handy little code snippet. Sometimes you find yourself needing to know the number of days in any given month. The code below will get you the last day of the month. I'm using the current month but you could use any month. You just need to know the month and year you're looking for. The magic lies in the DateTime.DaysInMonth method. You pass in the year and month and it returns the number of days in that month. The code below is pretty self explanatory.

static void Main( string[] args )
{
   DateTime now = DateTime.Now;

   int daysInMonth = DateTime.DaysInMonth( now.Year, now.Month );

   String dateFormat = String.Format( "Last day of the month is - {0}/{1}/{2}", now.Month, daysInMonth, now.Year);

   Console.WriteLine( dateFormat);

   Console.ReadKey();

}

And a brief picture showing the output, obviously I ran this is October 2011.

C# Get the ip address of a host name

2011-08-15T10:25:00.003-07:00

Often times you want to find the ip address of a host name. This function will do this for you. It returns the first address.

using System.Net;

public string GetIPAddress(string sHostName)
{
   IPHostEntry ipEntry = Dns.GetHostByName(sHostName);
   IPAddress [] addr = ipEntry.AddressList;
   string sIPAddress = addr[0].ToString();

   return sIPAddress;

}

C# format date times for different locals (localization and globalization), DateTimeFormatInfo

2011-07-15T10:01:00.001-07:00

Working on a project recently I found we were presenting date/time data to a variety of users in various countries. Each country uses it's own date/time formatting. Here in the US it's often MM/dd/yyyy, however in Europe it's often dd/MM/yyyy and in Asia they don't even have the slashes they use special characters that designate year, month, and day. At first we were going to come up with localized versions of all the possible date/time combinations you can display (June 6th, 1977, 6/25/77, etc) but Microsoft has an even better solution already in place.

static void Main( string[] args )
{
         DateTime dt = DateTime.Now;

         // let's create some different date times for different cultures

         // JAPANESE
         CultureInfo culture = new CultureInfo("ja-JP");
         DateTimeFormatInfo formatInfo = culture.DateTimeFormat;
         String time = dt.ToString( formatInfo.FullDateTimePattern, culture );
         MessageBox.Show( time );

         // ENGLISH
         culture = new CultureInfo( "en-US" );
         formatInfo = culture.DateTimeFormat;
         time = dt.ToString( formatInfo.FullDateTimePattern, culture );
         MessageBox.Show( time );

         // SIMPLIFIED CHINESE
         culture = new CultureInfo( "zh-CN" );
         formatInfo = culture.DateTimeFormat;
         time = dt.ToString( formatInfo.FullDateTimePattern, culture );
         MessageBox.Show( time );

         // FRENCH
         culture = new CultureInfo( "fr-FR" );
         formatInfo = culture.DateTimeFormat;
         time = dt.ToString( formatInfo.FullDateTimePattern, culture );
         MessageBox.Show( time );

         Console.ReadKey();

}

Looking at the code, we take the current date time and use the format string from the DateTimeFormatInfo to convert the current date time into the date time of the specified culture. In this example I'm using the FullDateTimePattern, but the DateTimeFormatInfo class has a many different formats you can use.

You can read about all the different formats at MSDN.

I hope this example helps you easily get date/times formatted into the various cultures. I know I've found it quite useful.

Using more complicated PInvoke calls

2011-06-22T09:21:00.001-07:00

In my last blog post I covered using a very basic PInvoke call to an unmanaged dll that returned an integer. For basic data types int, char, double, float, etc you don't need to do any manual marshaling. However, especially with the Win32 API you will find yourself needing to use more complicated types. Even getting a string back from an unmanaged dll takes more work, and then we have classes, structs, arrays, etc we need to deal with.

Let's look at some unmanaged dll signatures

extern "C"
{
   struct
   {
      char* NAME,
      char* ADDRESS,
      int age
   } PERSON;

   void FillByteArray( unsigned char* byteArray, int arrayLength );

   const char* GetLastErrorMessage();

   void FillAStruct( PERSON* pPerson );

}

Now here we have three functions; one fills a byte array, one returns a string, and another modifies a struct we've defined. Nothing complicated on the C++ side but we need to be careful when we start using pinvoke to call these functions. Let's look at some C# code that we can use to call these functions.

First let's fill that byte array with some data. Now I know you won't know the size of the array every time but after working with pinvoke arrays it's better if you can pass in the size of the array, it makes working with them much easier.

Let's start with the byte array

[DllImport(MyDll.dll)]
public static extern void FillByteArray( byte[] array, int arrayLength );

C/C++ treats arrays as pointers, so we're going to let the framework handle the memory management for us and just pass in an array with the array length. We can let the .net framework handle the memory mapping from our call to the actual dll memory use. The above function works very well for basic data types, but we often find ourselves needing to use more complicated types like strings and structs when dealing with unmanaged code. I will cover those items next.

Let's look at the function

const char* GetLastErrorMessage();

You might think

[DllImport(MyDll.dll)]
public static extern string GetLastErrorMessage();

Would be enough. Sadly dealing with strings gets complicated when making pinvoke calls. I have found when dealing with any strings in pinvoke calls it's simply better to use the IntPtr class with the Marshal static helper functions. Let's look at some code below.

// declare the function
[DllImport(MyDll.dll)]
public static extern IntPtr GetLastErrorMessage();

// call the function and get back and IntPtr
IntPtr ptrResult = GetLastErrorMessage();

// always check we have a valid pointer before calling the marshal code
// now we need to convert this pointer back to a string
if( ptrResult != IntPtr.Zero )
{
   // this will convert the pointerto an ansi string
   // there are other methods, but we always use ansi strings
   // look at the marshal documentation for the other string options
   String errorMessage = Marshal.PtrToStringAnsi(ptrResult);
}

Console.WriteLine( errorMessage );

Now let's take a look at the final example. Passing in a struct that the unmanaged code can read/modify etc. This one takes a bit more work but is very handy, especially since many of the Win32 APIs take their own struct definitions as input parameters. Now you will need to know the structure of the struct you plan to use. This isn't an issue usually when you have access to the source code or documentation but it needs to be noted.

First we need to have a struct that matches the struct in the unmanaged side. You can use a class if desired but I have found it easier to make a struct that matches exactly. I often find myself using an internal private struct to make the call and that using a helper class that converts the struct to a standard C# class.

So let's look at some C# code. First we need to create a struct that matches that unmanaged side struct. From above wherever we have string, use an IntPtr. For the int we can match the basic data type.

public struct Person
{
   public IntPtr name;
   public IntPtr address;
   public int age;
}

C# using PInvoke to call an unmanaged DLL

2011-05-16T11:52:00.000-07:00

Recently I've found myself having to do some pinvoking with .net. Microsoft offers an excellent primer on the subject.

http://msdn.microsoft.com/en-us/library/aa288468(v=vs.71).aspx

For it's many great benefits the .net framework doesn't do everything. You will find yourself having to invoke a win32 API function call at some point in your career.

I'm going to offer some quick and dirty samples on getting data back and forth using the platform invoke. First you cannot invoke any classes using pinvoke. You get 1 function call at a time. If you want classes you will need to write a custom CLI/C++ wrapper. But that goes beyond the scope of this post.

First let's look at the unmanaged\win32 side of things. Let's say you have a dll called MyDll.dll. In this dll you have a bunch of functions.

// this lets use export functions from the dll
#define  DllExport  __declspec( dllexport ) 

// first we use extern "C" so we don't get name mangling in the dll
// .net doesn't play well with C++ function names so we must use the extern
extern "C"
{    
    // we're going to export this function using the __stdcall calling convention
    // .net uses __stdcall by default, so we want to ensure we have it here
    DllExport int __stdcall Add( int A, int B )
    {
        return A + B;
    }
}

So a quick re-cap, we're going to export a single function called Add, using the __stdcall calling convention. Now let's look at using this function in a .net application. The trick is to use the DllImport attribute, located in the System.Runtime.InteropServices namespace. Below is an example of using the DllImport to use our Add method.

[DllImport( "MyDll.dll" )]
public static extern int Add( int A, int B );

// call our add method!
int result = Add( 1, 2 );

.Net is actually very good at matching the basic data types (int, long, bool, etc). Strings, delegates, classes, structs, etc require more work to function correctly. For those we will start getting into more manual marshaling of data. I have found for most basic dll calls letting the framework handle the marshaling saves a lot of time.

C# More on threading, killing a thread, waiting for, or how to do a Thread.Join

2011-05-10T09:37:00.000-07:00

In my last post I used a ThreadPool to do some work. ThreadPools are great and I use them a lot. However many times I find myself really only needing 1 thread and I need to have some control over it. I may need to wait for it to finish, or more importantly I need to be able to control when it dies or completes its task. For this case I always use Thread.Join

As usual please peruse the MSDN documentation.

Thread.Join waits for the thread to complete before proceeding with any other operations. So simply creating a thread then calling Thread.Join can be useful in some UI operations I tend to not call Join until I'm ready to kill the thread entirely. The MSDN link above goes over the great details.

Now let's go over some quick code. This example creates a thread then waits for the user to press a key and terminates the thread.

Let's look at the main console code

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

namespace ThreadExample
{
    class Program
    {
        static void Main( string[] args )
        {
            // create a class for use in threading
            ThreadWorker worker = new ThreadWorker();
            worker.IsAlive = true;

            // let's create a thread to do some work
            // pass the worker classes DoWork method as the method to do the work in
            Thread t = new Thread( new ThreadStart( worker.DoWork ) );

            // start the thread
            t.Start();

            // let the thread run while we wait for a key press
            Console.ReadKey();

            // send the kill signal
            // and do the join to wait for processing to end
            worker.IsAlive = false;
            t.Join();

            Console.WriteLine( "Press any key to terminate..." );
            Console.ReadKey();

        }
    }
}

It starts a thread, sets it to be alive and then waits for a key press. Once they key is pressed it sets IsAlive to false and waits for the thread to terminate. Now let's look at the thread code.

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

namespace ThreadExample
{
    public class ThreadWorker
    {
        private volatile bool _isAlive = false;

        public bool IsAlive
        {
            get { return _isAlive; }
            set { _isAlive = value; }
        }

        public ThreadWorker()
        {
        }

        public void DoWork()
        {
            int i = 0;

            while( _isAlive )
            {
                Console.WriteLine( "Current iteration is {0}", i++ );
                Thread.Sleep( 100 );
            }
        }
    }
}

This thread takes a volatile bool (used for thread safety, not the best method, but it works for this example) and simply writes to the console while it's in the alive state.

Here is the output from the program

As you can see the thread runs until a key press is made and it terminates. This is a very basic example on how to create a thread and send it a kill signal. I used to be a big background worker user, but I find this method much quicker and easier to setup and use.

Threading in C# using the ThreadPool

2011-04-19T09:31:00.000-07:00

Threading is one of those topics that creates a lot of discussion in programming. Threading in C# is quite easy. However using it correctly, especially when you start doing data access or sharing information across threads it becomes difficult to keep everything in sync. For this example I'm going to focus on creating some basic threads that run and do some basic output to show we have concurrent threads running. You could create a thread and start it, then join, etc. I prefer to let .net handle the thread creation and use the ThreadPool to do all the thread management for us.

You can read more about the ThreadPool here:

MSDN Site

I normally don't post entire files but this post is a bit different. Let's start with the program that is running the threads. We create 20 threads and pass them an index and a ManualResetEvent. This is so we know which thread is exiting and we need to keep track of when the thread is done processing. If we don't care about when the thread terminates there is no need for the manual reset event. It's simply there for the WaitHandle.WaitAll call. The code is below.

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

namespace ThreadPoolManager
{
    class Program
    {
        static void Main( string[] args )
        {
            int count = 20;

            ManualResetEvent[] doneEvents = new ManualResetEvent[count];

            for( int i = 0; i < count; i++ )
            {
                // create a ManaulResetEvent that is set to fals
                // this means it's not done procvess
                doneEvents[i] = new ManualResetEvent( false );

                // create an instance of our threading helper class
                // passing int he index and manual reset event
                ThreadCounter threadCounter = new ThreadCounter( i, doneEvents[i] );

                // queue the worker items, they will run and terminate automatically
                ThreadPool.QueueUserWorkItem( new WaitCallback( threadCounter.DoWork ) );


            }

            // wait for all the threads to finish
            WaitHandle.WaitAll( doneEvents );

            // do some output and let the user press the enter key
            Console.WriteLine();
            Console.WriteLine( "Done processing...Pmsress any key to terminate" );

            Console.ReadKey();

        }
    }
}

This code uses a custom class called ThreadCounter. ThreadCounter simply takes and index and a manual reset event. In the code above we tell the ThreadPool to use the ThreadCounter's DoWork method. To use this we need to pass an object into the callback method that could potentially have state information in it that is useful to the thread. We're not doing anything with that information. All this basic example does is sleep for a random time between .5 and 5 seconds. See the code below.

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

namespace ThreadPoolManager
{
    /// <summary>
    /// A basic class used to hold a thread counter index
    /// </summary>
    public class ThreadCounter
    {
        #region Fields

        private int _index;

        private ManualResetEvent _doneEvent;

        #endregion

        #region Properties

        /// <summary>
        /// Gets or sets the index.
        /// </summary>
        /// <value>The index.</value>
        public int Index
        {
            get { return _index; }
            set { _index = value; }
        }

        #endregion

        /// <summary>
        /// Initializes a new instance of the <see cref="ThreadCounter"/> class.
        /// </summary>
        public ThreadCounter()
        {
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="ThreadCounter"/> class.
        /// </summary>
        /// <param name="index">The index.</param>
        public ThreadCounter( int index, ManualResetEvent doneEvent )
        {
            _index = index;
            _doneEvent = doneEvent;
        }

        /// <summary>
        /// Does the work.
        /// </summary>
        public void DoWork( object stateInfo )
        {
            // we want this thread to sleep for some random amount of time
            Random r = new Random();
            int sleepTime = r.Next( 500, 5000 );
            Thread.Sleep( sleepTime );

            Console.WriteLine( this.ToString() );

            // set our done event so that any wait handles know we're done
            _doneEvent.Set();

        }

        /// <summary>
        /// Returns a <see cref="System.String"/> that represents this instance.
        /// </summary>
        /// <returns>
        /// A <see cref="System.String"/> that represents this instance.
        /// </returns>
        public override string ToString()
        {
            return String.Format( "This is thread {0} exiting.", _index );
        }

    }
}

Below are the results from the program being run. As you can see the threads sleep for random times and are finishing in a random order.

I've attached the entire project in a zip file below for anyone to download.

Thread Pool Manager Zip File

C# Lock, Sleep, and Hibernate Windows

2011-02-23T15:59:00.000-07:00

This could be a very uncommon occurrence but you might find a need in C# to set the computers sleep or hibernate state. You might even need to lock the entire pc. .NET has two of the needs built in, the third you will need to do some pinvoking.


// set the computer to hibernate
bool retVal = Application.SetSuspendState( PowerState.Hibernate, false, false );

if( retVal == false )
{
   MessageBox.Show( "Unable to hibernate the system." );
}


// set the computer to suspended
bool retVal = Application.SetSuspendState( PowerState.Suspend, false, false );

if( retVal == false )
{
   MessageBox.Show( "Unable to suspend the system." );
}

// lock the workstation
// we need to import from user32.dll, the LockWorkStation function
[DllImport("user32.dll", SetLastError = true)]  
static extern bool LockWorkStation();  

bool result = LockWorkStation();  
  
if (result == false)  
{  
   // TODO: an error occured
}

The Application.SetSuspendState is the big call here. Here is the MSDN link:

http://msdn.microsoft.com/en-us/library/system.windows.forms.application.setsuspendstate.aspx

MFC get your external ip address

2011-02-17T10:12:00.001-07:00

I recently wrote a program in MFC that would monitor your ip address. This was great but I soon realized if your behind a NAT of some kind you get your internal ip address. I soon realized a need to know my external ip address. There is no built in functionality to do this in windows so you have to ping an outside server or website that will tell you what your ip address is. There are several ways to do this sockets, an http request, or urlmon. Many people say sockets is the best since you can use any version of windows and create a socket. The issue is the socket code is extremely long and complicated. I only need to support windows 2000 and above so I decided using the urlmon way was much simpler and faster. Here is some code in MFC to hit an outside website which returns your IP address in file that you then parse for the data.

This is in a class with a CString member variable called m_strExternalIp.


m_strExternalIp = _T( "Unavailable" );

try
{    
    /*

        to make the UrlDownloadToFile call you need the following defined

        #include <urlmon.h>

        #pragma comment(lib, "urlmon.lib")

        */

     // holds the url to check and the name of the file to write the data to
    TCHAR url[47] = _T("http://checkip.dyndns.org/Current IP Check.htm");
    TCHAR file[7] = _T("ip.txt");

     // here is the urlmon.dll method call, see note above
    if( URLDownloadToFile( 0, url, file, 0, 0) == S_OK )
    {
        CStdioFile file;

         // open the file for reading
        if( file.Open( _T("ip.txt"), CFile::modeRead | CFile::modeNoTruncate ) )
        {
            file.ReadString( m_strExternalIp );
 
             // file if successful is in format
            // <html><head><title>Current IPCheck</title></head><body>Current IP Address: 174.52.71.72</body></html>
            if( m_strExternalIp.GetLength() > 110 )
            {
                m_strExternalIp = _T( "Unable to access IP check site" );
            }
            else
            {
                m_strExternalIp = m_strExternalIp.Mid( m_strExternalIp.Find( _T(": ") ) + 1, m_strExternalIp.GetLength() - m_strExternalIp.Find( _T("</body>") ) - 1 );
             }

             // always close the file
            file.Close();

        }
    }
    else
    {
        m_strExternalIp = _T( "Unable to access IP check site" );
    }
  }
 catch( CException* ex )
 {
     // write any errors to a log file
    TCHAR   szCause[255];
    CString strFormatted;

    ex->GetErrorMessage(szCause, 255);

    strFormatted = _T("The following error occurred: ");
    strFormatted += szCause;

    CStdioFile file(_T("error_log.txt"), CFile::modeWrite | CFile::modeNoTruncate );

    if( file )
    {
        file.WriteString( strFormatted );
    }

    file.Close();

    delete ex;

}

Read more about the urlmon stuff on MSDN

http://msdn.microsoft.com/en-us/library/ms775123(v=vs.85).aspx

Using google maps API for driving directions

2011-02-14T12:09:00.002-07:00

This is a bit different than my usual blog postings but I think it will help a lot of people. I recently have found a need to generate a Google Map with driving directions based on some customer input. After a few hours looking over some javascript API's I found a very simple solution on Google.com itself. There are a few different versions of the API and this solution uses version 2.0. I believe the current version is 3.0. I have no clue when if ever they will deprecate the API but it could happen. They also state if you call this service more than 2,500 times a day you will get banned so don't abuse the service. My use is light at best maybe once or twice a day. I have found it to be fairly fast and light weight.

UPDATE!!

Looks like Google wants you to have a key to use the maps. You will need to signup for a key here:

http://code.google.com/apis/maps/signup.html

It takes a few seconds and you will need to add the key to the query string used.

Now onto the code!

It just takes some HTML and JavaScript.

<html xmlns="http://www.w3.org/1999/xhtml"  xmlns:v="urn:schemas-microsoft-com:vml">
  <head>
    <title>Google Maps JavaScript API Example: Simple Directions</title>
    <meta http-equiv="content-type" content="text/html; charset=UTF-8"/>
    <script src="http://maps.google.com/maps?file=api&v=2.x&key=YOUR_KEY_HERE"
      type="text/javascript"></script>
    <script type="text/javascript">
    function gup( name )
    {
        name = name.replace(/[\[]/,"\\\[").replace(/[\]]/,"\\\]");
        var regexS = "[\\?&]"+name+"=([^&#]*)";
        var regex = new RegExp( regexS );
        var results = regex.exec( window.location.href );
       
        if( results == null )
            return "";
        else
            return results[1];
    }
   
    // Create a directions object and register a map and DIV to hold the
    // resulting computed directions

    var map;
    var directionsPanel;
    var directions;

    function initialize() {
      map = new GMap2(document.getElementById("map_canvas"));
      directionsPanel = document.getElementById("route");
      directions = new GDirections(map, directionsPanel);
      directions.load('from: gup('origin') to: ' + gup('destination') + "'");
    }
   
    function printMap() {
        var button = document.getElementById("buttonPrint");
        button.style.visibility ='hidden'; //hide
        print();
        button.style.visibility ='visible'; // show  
    }
   
    </script>
  </head>

  <body onload="initialize()">
    <input type="button" value="print" id="buttonPrint" onclick="printMap();" />
    <div id="route" style="width: 480px; height:320px; border; 1px solid black;" />
    <br/>
    <div id="map_canvas" style="width: 480px%; height: 480px; border: 1px solid black;" />
    <br/>
  </body>
</html>

Let's look at the HTML, we have 2 divs. One for the map and one for the instructions. I have them arranged in vertical order so they can be printed. You can lay them out however you want.

Now there are three JavaScript functions initialize, gup, and printMap. Initialize is the big one and creates the map using the Google Map API. The directions.load is what loads the directions from the origin to the destination. Now these values are passed in along the query string and are parsed using the gup function. The print map simply hides the print button and sends the page to the printer.

Now let's look at a quick example, assuming we've named our file map.html.

server.com/map.html?origin=&UTdestination=NV

Will give us a map from Utah to Nevada. You can enter full or partial address in standard JSON format. If your addresses have spaces you will need to ensure that the URL is fully encoded for this to work. I use asp.net so Server.UrlEncode is your friend.

You can read more about the different APIs directly from Google.com

http://code.google.com/apis/maps/index.html

And below is an image of the map generated above

C# using a transaction with ODBC

2011-02-14T10:01:00.000-07:00

Let's say your writing some data to the database and you need to make it transactional. You know where you need to rollback multiple statements or use multiple statements in one go. Normally you would do this in the database itself. But I have found a few times where you have to do this in .net. My latest was using mySQL to get the new index after I did an insert. I found the SQL to do so would work fine in a mySQL command prompt or in the phpMyAdmin SQL pane but their .net ODBC driver simply wouldn't allow it. Epic .net fail mySQL I guess your love for PHP has clouded your vision. So you end up needing to wrap up multiple SQL calls in a transaction to accomplish this. I have also had to do this it SQLSERVER but not on a scale like this. But regardless this is how you can use a .net transaction with multiple SQL statements.

You need to create an OdbcConnection. Then an OdbcCommand and OdbcTransaction. Set the command and transactions connection to the connection opened earlier. Then you call BeginTransaction on the transaction object and make all your SQL command calls. When you're done you try and finalize the transaction or if any errors occurred rollback the transaction. You can look at the code below for a good example.


// open a new connection using a default connection string I have defined elsewhere
using( OdbcConnection connection = new OdbcConnection( s_connectionString ) )
{
      // ODBC command and transaction objects
      OdbcCommand command = new OdbcCommand();
      OdbcTransaction transaction = null;

      // tell the command to use our connection
      command.Connection = connection;

      try
      {
           // open the connection
           connection.Open();

           // start the transaction
           transaction = connection.BeginTransaction();

           // Assign transaction object for a pending local transaction.
           command.Connection = connection;
           command.Transaction = transaction;

           // TODO: Build a SQL INSERT statement
           StringBuilder SQL = new StringBuilder();

           // run the insert using a non query call
           command.CommandText = SQL.ToString();
           command.ExecuteNonQuery();

           /* now we want to make a second call to MYSQL to get the new index 
              value it created for the primary key.  This is called using scalar so it will
               return the value of the SQL  statement.  We convert that to an int for later use.*/
           command.CommandText = "select last_insert_id();";
           id = Convert.ToInt32( command.ExecuteScalar() );

           // Commit the transaction.
           transaction.Commit();
     }
     catch( Exception ex )
     {
          Debug.WriteLine( ex.Message );

          try
          {
               // Attempt to roll back the transaction.
               transaction.Rollback();
            }
            catch
            {
                 // Do nothing here; transaction is not active.
              }
         }
}

C# Anti Aliasing when drawing

2011-02-09T14:20:00.000-07:00

In a previous post I talked about how to set anti-aliasing on text in C#. Now you may find yourself needing to set anti aliasing when drawing shapes. This is very easy to do using the GDI+ graphics object. The trick is to use the SmoothingMode and PixelOffsetMode.

Now some quick code

protected override void OnPaint( PaintEventArgs e )
{
     e.Graphics.SmoothingMode = SmoothingMode.AntiAlias;
     e.Graphics.PixelOffsetMode = PixelOffsetMode.HighQuality;
     e.Graphics.DrawEllipse( new Pen( new SolidBrush( Color.Red ), 1.0f ), new Rectangle( 5, 5, 200, 200 ) );

     e.Graphics.SmoothingMode = SmoothingMode.HighQuality;
     e.Graphics.PixelOffsetMode = PixelOffsetMode.HighQuality;
     e.Graphics.DrawEllipse( new Pen( new SolidBrush( Color.Red ), 1.0f ), new Rectangle( 210, 5, 200, 200 ) );

     e.Graphics.SmoothingMode = SmoothingMode.HighSpeed;
     e.Graphics.PixelOffsetMode = PixelOffsetMode.HighQuality;
     e.Graphics.DrawEllipse( new Pen( new SolidBrush( Color.Red ), 1.0f ), new Rectangle( 415, 5, 200, 200 ) );

     e.Graphics.SmoothingMode = SmoothingMode.Default;
     e.Graphics.PixelOffsetMode = PixelOffsetMode.HighQuality;
     e.Graphics.DrawEllipse( new Pen( new SolidBrush( Color.Red ), 1.0f ), new Rectangle( 620, 5, 200, 200 ) );


     base.OnPaint( e );
}

Now as you can see we start with the higher quality AA setting and move down to the default setting. I kept the PixelOffsetMode to high quality for all tests. You can play around with the different settings to achieve the desired results. We do a lot of image generation and have them both set to as high as possible and don't see a large impact on drawing performance by using AA.

Antialiasing Text with C#

2011-01-28T09:20:00.001-07:00

Lately I have found myself having to use anti-aliasing in a lot of our rendering code to improve the output look our images. To help others here is a snippet of code to anti alias text.

protected override void OnPaint( PaintEventArgs e )
{
    base.OnPaint( e );
    Font font = new Font( "Tahoma", 12.0f, FontStyle.Regular );

    e.Graphics.TextRenderingHint = TextRenderingHint.SystemDefault;
    TextRenderer.DrawText( e.Graphics, "Antialiased Text", font, new Point( 0, 20 ), Color.Black );

     e.Graphics.TextRenderingHint = TextRenderingHint.AntiAlias;
     TextRenderer.DrawText( e.Graphics, "Antialiased Text", font, new Point( 0, 40 ), Color.Black );

    e.Graphics.TextRenderingHint = TextRenderingHint.AntiAliasGridFit;
    TextRenderer.DrawText( e.Graphics, "Antialiased Text", font, new Point( 0, 60 ), Color.Black );

    e.Graphics.TextRenderingHint = TextRenderingHint.ClearTypeGridFit;
    TextRenderer.DrawText( e.Graphics, "Antialiased Text", font, new Point( 0, 80 ), Color.Black );
}

You can see the results below:

The trick in the code above is the TextRenderingHint on the graphics object. The 4 above are probably the most common but there are a few more. You can read about them on MSDN:

http://msdn.microsoft.com/en-us/library/system.drawing.graphics.textrenderinghint.aspx

You can also anti alias drawing lines, circles, fills, etc but that will be covered in another post.

C# Formatting DateTime to a String

2010-10-25T14:57:00.000-07:00

Often times you find yourself needing to convert a DateTime object into a useful string representation. Here are some basic parameters to the DateTime.ToString() method.

MM/dd/yyyy	08/25/2010
dddd, dd MMMM yyyy	Tuesday, 25 August 2010
dddd, dd MMMM yyyy	HH:mm Tuesday, 25 August 2010 06:30
dddd, dd MMMM yyyy	hh:mm tt Tuesday, 25 August 2010 06:30 AM
dddd, dd MMMM yyyy	H:mm Tuesday, 25 August 2010 6:30
dddd, dd MMMM yyyy	h:mm tt Tuesday, 25 August 2010 6:30 AM
dddd, dd MMMM yyyy HH:mm:ss	Tuesday, 25 August 2010 06:30:07
MM/dd/yyyy HH:mm	08/25/2010 06:30
MM/dd/yyyy hh:mm tt	08/25/2010 06:30 AM
MM/dd/yyyy H:mm	08/25/2010 6:30
MM/dd/yyyy h:mm tt	08/25/2010 6:30 AM
MM/dd/yyyy h:mm tt	08/25/2010 6:30 AM
MM/dd/yyyy h:mm tt	08/25/2010 6:30 AM
MM/dd/yyyy HH:mm:ss	08/25/2010 06:30:07
MMMM dd	August 25
MMMM dd	August 25
yyyy'-'MM'-'dd'T'HH':'mm':'ss.fffffffK	2010-08-25T06:30:07.7199252-04:00
yyyy'-'MM'-'dd'T'HH':'mm':'ss.fffffffK	2010-08-25T06:30:07.7199252-04:00
ddd, dd MMM yyyy HH':'mm':'ss 'GMT'	Tue, 25 Aug 2010 06:30:07 GMT
ddd, dd MMM yyyy HH':'mm':'ss 'GMT'	Tue, 25 Aug 2010 06:30:07 GMT
yyyy'-'MM'-'dd'T'HH':'mm':'ss	2010-08-25T06:30:07
HH:mm	06:30
hh:mm tt	06:30 AM
H:mm	6:30
h:mm tt	6:30 AM
HH:mm:ss	06:30:07
yyyy'-'MM'-'dd HH':'mm':'ss'Z'	2010-08-25 06:30:07Z
dddd, dd MMMM yyyy HH:mm:ss	Tuesday, 25 August 2010 06:30:07
yyyy MMMM	2010 August
yyyy MMMM	2010 August

C# get number of messages in message queue (MSMQ)

2010-09-15T12:21:00.000-07:00

Working with message queues in .net is incredibly easy. However I often find myself having to get the number of message in queue for monitoring, etc. That aspect of the message queue framework is a bit lacking. There are a few options available but they all have some problems.

You can call GetAllMessages() right off the message queue object. This code works, however it gets a copy of EVERY message queue item currently in the queue. Got 10 items, you get ten. Now do this with 10,000 items every second and it starts to become a problem.

It's also possible to enumerate through all the messages in the queue and take a count of them manually but if your queue is busy this can cause invalid cursor exceptions to happen. This is the main reason I moved away from doing this.

You can also do some performance counter work but I find that code to be too complex and very fragile and prone to breakage.

I've found the best bet is to go with the COM/Win32 route. The nice thing here is you don't have to do any PInoke calls but you do have to do some Marshalling. Now this code required the MSMQ 3.0 be installed. This is the latest version and should be fairly universal at this point in time.

First add a reference to the MSMQ 3.0 Object library to your project.

Now add a

using MSMQ;

statement to your class, etc.

The magic happens in the MSMQManagement class. The code below uses a MessageQueue I have already set up as m_imgRequestQueue. You create a new MSMQManagement class and set it up and then call the Init method. The machine name and formatName parameters are the only required params so that is why the path is set to null. After init you can then use the MessageCount property to access the number of messages in the queue. And as with any COM object in .NET you must always release it when you're done with it.

 // setup the queue management COM stuff
MSMQManagement _queueManager = new MSMQManagement();

object machine = new object();
machine = m_imgRequestQueue.MachineName;

object path = null;

object formatName = new object();
formatName = m_imgRequestQueue.FormatName;

_queueManager.Init( ref machine, ref path, ref formatName );

// once inited you can use the MessageCount property (int) to get the]
// number of messages in the queue
_queueManager.MessageCount

// ALWAYS release COM objects when you're done with them
Marshal.ReleaseComObject( _queueManager );

C# Serialize an object to/from XML

2010-07-27T09:22:00.001-07:00

There have been many times I've needed to serialize an object to/from XML. .NET makes this incredibly easy. With a few meta tags your class(es) can easily be serialized and deserialized. You can then take this even further any start applying custom attributes to have as much granular control over the serialization as you want.

For instance lets' take a very basic class with some data and properties.

public class Person
{
    int _age;
    String _name;

    /// Gets or sets the Age of the person.
    public int Age
    {
       get { return _age; }
       set { _age = value; }
    }

    /// Gets or sets the Name of the person.
    public String Name
    {
       get { return _name; }
       set { _name = value; }
    }

    /// Creates a new instance of the Person class
    public Person()
    {
    }

}

Now let's take this class and add the [Serializable] attribute.

[Serializable]
public class Person
{
    int _age;
    String _name;

    /// Gets or sets the Age of the person.
    public int Age
    {
       get { return _age; }
       set { _age = value; }
    }

    /// Gets or sets the Name of the person.
    public String Name
    {
       get { return _name; }
       set { _name = value; }
    }

    /// Creates a new instance of the Person class
    public Person()
    {
    }

}

You can now take this class to/from XML. When you serialize it the .net parser will look at all public properties and fields and convert them to XML.

You will end up with XML that will look like the following:

<xml version="1.0" />
<Person>
<Age>X</Age>
<Name>Y</Age>
</Person>

Whatever values you have stored in the name and age fields will be written to the XML.

Obviously this is a very primitive example of what you can do to get your classes into XML. There are a wide variety of XML Attributes you can apply to your classes to more fully control the serialization. This is a basic example of how to get your class into and back from XML.

A quite note on data types. All the .net value types (int, String, etc) can be converted to XML; however some of the more complex reference types (classes) may not be convertible. Be careful when serializing all your properties, etc fully support serialization.

C# Equal vs CompareTo

2010-05-24T13:38:00.002-07:00

Out of curiosity I decided to run some speed tests on strings using the Equals and CompareTo methods. I wrote some quick code and came up with some interesting results:

This test was run for 10000000 iterations. The Equals methods trounced the CompareTo method. Under the hood Equals stops when the first character that doesn't match is found. CompareTo continues on to the end of the string all the time. However this was a case insensitive search with no culture information. Adding more variables may cloud the water a bit, but that is going to be reserved for future posts. The code used in the test can be seen below.

using System;
using System.ComponentModel;
using System.Collections.Generic;
using System.Text;
using System.IO;
using System.Net;
using System.Threading;

namespace Sandbox
{
    class Program
    {
        static void Main( string[] args )
        {
            const int counter = 10000000;

            int i = 0;

            int count = 0;

            String string1 = "ASq2qw;m;kl1212ed'12,12lml!@)Eki3";
            String string2 = "AS@_)#L:;sladf-030-!+)I@1=0-23i1[pk1=-12i=}";
            String string3 = "ASq2qw;m;kl1212ed'12,12lml!@)Eki3";

            DateTime start;

            TimeSpan span;

            // run some string comparisons
            Console.WriteLine( "Running tests" );
            Console.WriteLine();

            // first test Equals on strings that aren't equal one another
            start = DateTime.Now;

            for( i = 0; i < counter; i++ )
            {
                if( string1.Equals( string2 ) )
                {
                    count++;
                }
            }

            span = DateTime.Now - start;
            Console.WriteLine( "Strings that aren't equal using Equals() : " + span.TotalSeconds );
            
            // second test using CompareTo on strings that aren't equal
            start = DateTime.Now;

            for( i = 0; i < counter; i++ )
            {
                if( string1.CompareTo( string2 ) == 0 )
                {
                    count++;
                }
            }

            span = DateTime.Now - start;
            Console.WriteLine( "Strings that aren't equal using CompareTo() : " + span.TotalSeconds );

            // third test using Equals on strings that are equal
            start = DateTime.Now;

            for( i = 0; i < counter; i++ )
            {
                if( string1.Equals( string3 ) )
                {
                    count++;
                }
            }

            span = DateTime.Now - start;
            Console.WriteLine( "Strings that are equal using Equals() : " + span.TotalSeconds );

            // fourth test using CompareTo on strings that are equal
            start = DateTime.Now;

            for( i = 0; i < counter; i++ )
            {
                if( string1.CompareTo( string3 ) == 0 )
                {
                    count++;
                }
            }

            span = DateTime.Now - start;
            Console.WriteLine( "Strings that are equal using CompareTo() : " + span.TotalSeconds );
            Console.WriteLine();
            Console.WriteLine( "Press any key to continue . . ." );
            Console.ReadKey();

        }
    }
}

C# using a background worker

2010-05-14T08:24:00.000-07:00

This post is going to focus on creating and using a BackgroundWorker object. Background workers are found in the System.ComponentModel namespace. They're pretty easy to use. You just create a new object, assign a few properties and event handlers and let it do its thing.

using System;
using System.ComponentModel;

First let's create a background worked object and set it up.

Pstatic void Main( string[] args
{
   // create the background worker object
   BackgroundWorker _worker = new BackgroundWorker();

   // tell the background worker it can be cancelled and report progress
   _worker.WorkerReportsProgress = true;
   _worker.WorkerSupportsCancellation = true;

   // a worker thread object where the actual work happens
   WorkerThread thread = new WorkerThread();

   // add our event handlers
   _worker.RunWorkerCompleted += new RunWorkerCompletedEventHandler( thread.RunWorkerCompleted );
   _worker.ProgressChanged += new ProgressChangedEventHandler( thread.ProgressChanged );
   _worker.DoWork += new DoWorkEventHandler( thread.DoWork );

   // start the worker thread
   _worker.RunWorkerAsync();

   // wait for it to be completed
   while( !_worker.CancellationPending )
   {
      // sleep for a second
      Thread.Sleep( 1000 );
    }

    Console.ReadKey();

}

There are two properties WorkerReportsProgress and WorkerSupportsCancellation. These are set to false by default. You will need to set them to true if you want to be able to get progress reports back from the worker or cancel it before the work is done.

Now the next section is a class that actually does the work. I called mine ThreadWorker but it can be anything.

public class WorkerThread
{
    public void DoWork( object sender, DoWorkEventArgs e )
    {
       //get a handle on the worker that started this request
       BackgroundWorker workerSender = sender as BackgroundWorker;

       // loop through 10 times and report the progress back to the sending object
       for( int i = 0; i < 10; i++ )
       {
          // tell the worker that we want to report progress being made
          workerSender.ReportProgress( i );
          Thread.Sleep( 100 );
       }

       // cancel the thread and send back that we cancelled
       workerSender.CancelAsync();
       e.Cancel = true;

    }

    public void RunWorkerCompleted( object sender, RunWorkerCompletedEventArgs e )
    {
       Console.WriteLine( "Worker Done!!" );          
    }

    public void ProgressChanged( object sender, ProgressChangedEventArgs e )
    {
      // print out the percent changed
      Console.WriteLine( e.ProgressPercentage );
    }
}

Notice the three methods correspond to the 3 event handlers above. When creating the BackgroundWorker you can tell it what methods to call for certain events. I prefer to use a class that is built specifically for those events.

So I hope this helps people figure out and use BackgroundWorker objects. I find them very handy especially in UI programming when I need to report on how much work is being done, etc. Or when I need to be able to know when a thread is done and have the ability to cancel it.

C# Creating a Singleton

2010-04-14T15:07:00.003-07:00

A lot of people talk trash about the Singleton and how it should be avoided like the plague. I think like a lot of things it has its place and can be used effectively in certain situations. I'm going to leave what those situations are alone for the time being and just focus on creating a nice thread safe lazy init singleton class.

public sealed class Singleton
{
    Singleton()
    {
    }

    public static Singleton Instance
    {
        get
        {
            return Nested.instance;
        }
    }
    
    class Nested
    {
        // Use an explicit static constructor to tell the C# compiler
        // not to mark type as beforefieldinit
        static Nested()
        {
        }

        internal static readonly Singleton instance = new Singleton();
    }
}

Binding to a DataGridView with a custom collection

2010-04-07T15:51:00.005-07:00

Often times I find the need to bind a custom collection to a datagridview in a windows form. .Net makes this easy and with some simple code we can achieve some pretty quick results.

First drop a DataGridView onto your form. Click the little white arrow on the top right of the grid and select Choose Data Source. This should bring up wizard that allows you to select what you want to bind to the grid.

Select Object and click Next. Now select the class you want to bind too. You can select from all the existing references in your project or add a new one by clicking Add Reference. When you've selected the class to use click the Finish button.

Now that you've got the design done let's write some code to show our data in the grid. I have created a custom collection called Playlists that contains a list of Playlist items. My datagrid is bound to this collection and uses its public properties as the values for the columns.

public class Playlist
    {
        private String _title = String.Empty;
        private String _directory = String.Empty;

        /// <summary>
        /// Gets or sets the name.
        /// </summary>
        /// <value>The name.</value>
        public String Title
        {
            get { return _title; }
            set { _title = value; }
        }

        /// <summary>
        /// Gets or sets the directory.
        /// </summary>
        /// <value>The directory.</value>
        public String Directory
        {
            get { return _directory; }
            set { _directory = value; }
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="Playlist"/> class.
        /// </summary>
        public Playlist()
        {
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="Playlist"/> class.
        /// </summary>
        /// <param name="ID">The ID.</param>
        /// <param name="title">The title.</param>
        /// <param name="Directory">The directory.</param>
        public Playlist( int ID, String title, String Directory )
        {
            _playlistID = ID;
            _title = title;
            _directory = Directory;
        }

        /// <summary>
        /// Returns a <see cref="System.String"/> that represents this instance.
        /// </summary>
        /// <returns>
        /// A <see cref="System.String"/> that represents this instance.
        /// </returns>
        public override string ToString()
        {
            return base.ToString();
        }
    }

The collection class

public class Playlists:Collection<Playlist>
    {
    }

Now in the forms code behind you set the actual instance of the collection you want to bind as the BidingSource's DataSource. My BindingSource is called playlistsBindingSource. You can name it whatever you want when you're creating it in the above steps.

// create a custom collection
private Playlists _playLists = new Playlists();

// TODO: add some items to the collection

// set the binding sources data source to our collection
this.playlistsBindingSource.DataSource = _playLists;

Now you can add/remove items from the binding source just as you would the collection. It has the same Add, Remove, RemoveAt functions a generic collection container does and your datagrid will automatically update its displayed items. You can even find get the actual object used to databind to each row and use its data if you need to.