Hacky Hacky

ReaderWriterLock(Slim) Extension Methods

Vijay Santhanam — Fri, 08 Aug 2008 06:28:00 GMT

With the .NET framework 3.5 came a new implementation of the reader writer lock that solved many flaws of the original design. Joe Duffy describes in detail what's new in ReaderWriterLockSlim, how it differs from the old version and why a new class was needed to do the same thing.

In most of my applications, when I use a reader writer lock I use them a lot. Fortunately, using the lock is straight forward:

var rwLock = new ReaderWriterLockSlim(LockRecursionPolicy.SupportsRecursion);
rwLock.EnterReadLock();

try {
    // do stuff  
} catch (Exception ex) {
    // handle exception 
} finally {
    // release the lock     
    rwLock.ExitReadLock(); 
}

But when you're acquiring/releasing locks a lot, your code is littered with try-catch-finally's.

This isn't an earth-shattering-world-heating-climate-cooling-mass-destruction problem, but I'm a big fan of simplifying and cleaning up code where ever I can - for no other reason than the KISS principle.

In C# 3.0, extension methods and lambda's provide us with a great way to extend and wrap existing class behaviour. I used lambdas in continuations in my ActionDisposable post to give a collection class some public locking.

With extension methods, I can extend the ReaderWriterLockSlim class itself to simplify the use of the lock.

using System;

namespace System.Threading {

    public static class ReaderWriteLockExtensions {
        #region Disposable

        struct Disposable : IDisposable {
            readonly Action action;

            public Disposable(Action action) {
                this.action = action;
            }

            public void Dispose() {
                action();
            }

        }

        #endregion          
        #region Lock Helpers

        public static IDisposable ReadLock(this ReaderWriterLockSlim l) {
            l.EnterReadLock();
            return new Disposable(l.ExitReadLock);
        }

        public static IDisposable UpgradableReadLock(this ReaderWriterLockSlim l) {
            l.EnterUpgradeableReadLock();
            return new Disposable(l.ExitUpgradeableReadLock);
        }

        public static IDisposable WriteLock(this ReaderWriterLockSlim l) {
            l.EnterWriteLock();
            return new Disposable(l.ExitWriteLock);
        }

        #endregion     
    } 
}

ReadLock(), UpgradableReadLock() and WriteLock() return IDisposable, which can be used in using() blocks that automatically clean-up even when exceptions are thrown.

var rwLock = new ReaderWriterLockSlim();
using (rwLock.ReadLock()) {
    // do reading stuff 
}

It's a little easier to read, and has certainly cleaned up our heavily locked code.

LINQ & Lambda, Part 4: Lucene.Net

Vijay Santhanam — Sun, 20 Jul 2008 15:51:26 GMT

Lucene is a jewel in the open source world - its a highly scalable, fast search engine written in Java. Its class-per-class C# cousin - Lucene.Net - is also a precious stone in the .NET universe. Over the years, Lucene.Net has gained considerable popularity and is used in a wide range of products.

C|NET, Fogbugz on Demand and Wikipedia are just a few sites that use Lucene.Net for indexing and searching their vast content. Even Microsoft has been forced to deal with a Lucene powered competitor Outlook extension that embarrasses the built-in search engine.

It's an extremely useful tool in the belt of any software engineer. Not just for it's design and implementation of modern information retrieval theories, but for it's simple API too.

From my experiences, libraries with simple concepts have simple API's. Lucene is no different because the search engine concept is very simple. A search engine is a system for finding text from a large set very quickly.

At the heart of the engine is the index (similar to a database table) with fields (like database columns) that contains documents (like database rows). To search one must write a query and give it to the engine to finding matching documents. The query language for a database is SQL and for Lucene it's a query object (you can construct complex queries by composing an object graph of query instances).

Search engines are super fast for finding text because documents are stored in an inverted index (where the terms of each field is tokenized, hashed and sorted at index time).

In contrast to database queries, search engines can calculate relevance scores when searching. This is because they use a better querying model called the vector space model instead of the classical boolean model. In the vector model, documents and queries are represented as vectors. The similarity between a query and any document can be calculated with simple vector operations. Documents with a higher similarity will appear higher in the results. Conversely, databases only know if rows meets the where criteria or not and cannot compute a relevance score - this true/false classification is how the boolean model got it's name.

Search engines are rad!! And with Lucene any developer can easily add a search engine to their application.

To satiate the rampant LINQ junkie within, I've been contributing to the LINQ to Lucene project - an open source LINQ provider framework.

My recent contribution to the project makes creating indexes and searching them even easier. Today, I'm going to demonstrate some features I've added so you too can easily Lucene-ify your application.

A common use of Lucene in applications is to complement the database with a Lucene index for searching. LINQ to Lucene offers this functionality out of the box with LINQ to SQL from data generated classes.

Let's start with the Northwind database. By following Scott Gu's instructions, you can create a DBML file with generated classes from the database schema. This demonstration only needs the Customer and Order table.

The next step is to inform LINQ to Lucene which classes to index and how they are indexed using attributes. We do this extending the Customer and Order generated classes and decorating them with attributes. If you don't know how to create partial classes, see Chris Sainty's post.

[Document]
public partial class Customer {
}

[Document]
public partial class Order {
}

Now we've marked these two classes as documents for indexing. The next step is to specify how each field is indexed. But, there is a bit of a problem with properties in generated classes. There is no way to add attributes to generated properties without spoiling the automatically generated files.

Our solution to this is to add the MetadataType property on the DocumentAttribute which tells Lucene to look at another class for the field attributes it needs. Like so:

[Document(Metadatatype= typeof(CustomerMetadata))]
public partial class Customer {
}

[Document(Metadatatype= typeof(OrderMetadata))]
public partial class Order {
}

Now we can create fake properties on our metadata types to specify field characteristics. The return type of the fake properties doesn't matter, only the name has to match.

public class CustomerMetadata {

    [Field(FieldIndex.Tokenized, FieldStore.Yes, IsDefault = true)]
    public object ContactName { get; set; }

    [Field(FieldIndex.Tokenized, FieldStore.Yes, IsKey= true)]
    public object CustomerID { get; set; }

    [Field(FieldIndex.Tokenized, FieldStore.Yes)]
    public object ContactTitle { get; set; }

    [Field(FieldIndex.Tokenized, FieldStore.Yes)]
    public object CompanyName { get; set; }
}

public class OrderMetadata {

    [Field(FieldIndex.Tokenized, FieldStore.Yes, IsKey = true)]
    public object OrderID { get; set; }

    [Field(FieldIndex.Tokenized, FieldStore.Yes, IsDefault = true)]
    public object CustomerID { get; set; }

    [Field(FieldIndex.Tokenized, FieldStore.Yes)]
    public object ShipName { get; set; }

    [Field(FieldIndex.Tokenized, FieldStore.Yes)]
    public object ShipAddress { get; set; }

    [Field(FieldIndex.Tokenized, FieldStore.Yes)]
    public object ShipCity { get; set; }

    [Field(FieldIndex.Tokenized, FieldStore.Yes)]
    public object ShipCountry { get; set; }
}

Now we've told Lucene.Net which properties to index and how to index them.

The FieldIndex property indicates whether or not the field is tokenized (i.e. split into parts). By default, this is UnTokenized to save index space.
The FieldStore property tells Lucene whether or not to store the original value in the index. Again, by default, this is NO to save index space.
IsKey should be true for the fields primary key. Only one property can be marked as the key, so LINQ to SQL classes with composite keys should have a new uniquely identifying property.
IsDefault tells Lucene which field is the default field for searching.

Now we're ready to create the index.

To create the index from a LINQ to SQL Data Context, we use the DatabaseIndexSet like so:

var dbi = new DatabaseIndexSet<NorthwindDataContext>(
                                         @"C:\index\",                  // index path                                          
                                         new NorthwindDataContext()     // data context instance                                          
                 ); 
dbi.Write();

By running this code, we'll create an index for the entire contents of the Customer and Order tables. LINQ to Lucene is smart enough to collect all the relevant data from the Northwind database, convert each row to a Lucene Document and add it to the index.

Sweet! We've got an index of the Customer and Order tables.

Now we can search for Customers or Orders.

Let's find all the Customers who are Marketing Managers...

var mmCustomers = from c in dbi.Get<Customer>()
                      where c.ContactTitle == "Marketing Manager"                       
                      select c;
 
Console.WriteLine("Marketing Manager Customers: Found {0}", mmCustomers.Count());

foreach (var customer in mmCustomers) {
    Console.WriteLine(customer.ContactName);
}

This very simple example demonstrates the query equality operator, but many other types of query are possible (including wildcards, prefixes, proximities). You can find more ways to query on the LINQ to Lucene homepage.

In future posts, I'll demonstrate more complex query examples and how to supply custom formatters for properties.

To see the source of LINQ to Lucene, you can get the latest release. The sample project from this post is available for download here.

NOTE: The sample project uses the Northwind database as a data source. Northwind can be downloaded and installed to your SQL Server instance from here.

LINQ & Lambda, Part 3: Html Agility Pack to LINQ to XML Converter

Vijay Santhanam — Mon, 26 May 2008 06:03:12 GMT

The Html Agility Pack brings flexible, versatile html parsing onto the .NET platform. It's a great toolkit for scraping websites that don't offer formal, documented APIs.

Under the hood, the agility pack has it's own parser that's deftly designed to parse malformed HTML in all it's nasty real-life forms.

For querying and traversing a parsed document, the pack offers a in-memory object graph, XPath and XSLT. Today I'd like to add a LINQ to XML converter for extra HTML agility in this new .NET 3.5 post-MIX '08 world.

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Xml.Linq;

using System.IO;

namespace HtmlAgilityPack

    public static class HtmlDocumentExtensions

        public static XDocument ToXDocument(this HtmlDocument document)

            using (StringWriter sw = new StringWriter())

                document.OptionOutputAsXml = true;

                document.Save(sw);

                return XDocument.Parse(sw.GetStringBuilder().ToString());

For a demonstration on how to use this, I'm going to partially solve a scraping problem I came across a few days ago. Basically, I needed to find all the images on a webpage, order them by descending size, and list them to the user for their selection. Their choice would be used to generate a thumbnail. Social content sites like Digg and Mixx do something similar, but seem to download the top 10 biggest images, thumbnail them anyway and let the user choose. In the following example, I'm going to simply find all the images in the right order and let the reader do the thumbnailing :)

The first step is to download a page and convert it's HtmlDocument object graph into an XDocument.

HtmlWeb hw = new HtmlWeb();

string url = @"http://www.nytimes.com/2008/05/18/us/politics/18memoirs.html?hp";

Uri uri = new Uri(url);

HtmlDocument doc = hw.Load(url);

var xdoc = doc.ToXDocument();

Now we can find all the image tags with a simple LINQ expression.

var imgs =

        from el in xdoc.Descendants()

        where el.Name.LocalName == "img"

        select

        new {

            Src = el.Attribute(XName.Get("src")).Value,

};

The last step is to order them by descending size, but there's a couple of things to consider when reading the "width" and "height" from an image XElement.

"width" and "height" may not exist. These attributes aren't mandatory.
"width" and "height" may be expressed in percentages.
XElement.Attribute(XName.Get("width")).Value will throw a NullRefereceException if the attribute doesn't exist.

Every raster image has a width and height, even if the image tag doesn't. If the size cannot be seen on the tag, we could download and open the image to find out it's true height/width. A fast way to do this would be read the image header, but this post isn't about the Image class or reading images - just LINQ to HTML. For now, I'm going to create a default width and height of 0.

XName widthAttribute = XName.Get("width");

XName heightAttribute = XName.Get("height");

XName srcAttribute = XName.Get("src");

XAttribute defaultHeight = new XAttribute(heightAttribute, "0");

XAttribute defaultWidth = new XAttribute(widthAttribute, "0");

Now we can read the width and height in the LINQ expression allowing for defaults, and adding a hack for sizes expressed in percentages.

var imgs =
        from el in xdoc.Descendants()
        let width = Int32.Parse((el.Attribute(widthAttribute) ?? defaultWidth).Value.TrimEnd('%'))
        let height = Int32.Parse((el.Attribute(heightAttribute) ?? defaultHeight).Value.TrimEnd('%'))
        let metric = Math.Sqrt(width * height)
        where el.Name.LocalName == "img"         orderby metric descending         select          new { 
            Src = el.Attribute(srcAttribute).Value,
            Width = width,
            Height = height
        };

foreach (var image in imgs)

    Console.WriteLine("{0} Size: {1}x{2}",

        image.Src,

        image.Width,

        image.Height);

Hey presto! The image URLs get written to the console in the right order. The output for the new york times article looks like this:

Found 26 images

http://graphics7.nytimes.com/images/2008/05/18/us/18mem.span.jpg Size: 600x350
http://graphics7.nytimes.com/adx/images/ADS/14/60/ad.146024/sf.gif Size: 300x250
http://graphics7.nytimes.com/images/2008/05/17/us/18memoir_190.jpg Size: 190x285
http://graphics7.nytimes.com/ads/marketing/mm08/opinion_033108.jpg Size: 334x105
http://graphics7.nytimes.com/ads/marketing/mm08/opinion_052608.jpg Size: 334x105
http://graphics8.nytimes.com/images/2008/05/25/opinion/25moth_glanville.jpg Size: 151x151
http://graphics8.nytimes.com/images/2008/05/25/weekinreview/25moth_wong.jpg Size: 151x151
http://graphics8.nytimes.com/images/2008/05/23/fashion/25moth-brain1.ready.jpg Size: 151x151
http://graphics8.nytimes.com/images/2008/05/25/opinion/25moth_classic.gif Size:
151x151
http://graphics8.nytimes.com/images/2008/05/25/nyregion/thecity/25moth_crime.jpg Size: 151x151
http://graphics8.nytimes.com/images/2008/05/25/travel/25moth-trail.jpg Size: 151x151
http://graphics7.nytimes.com/images/blogs/thecaucus/thecaucus75.jpg Size: 75x75
http://graphics7.nytimes.com/ads/marketing/mm07/nyt-logo.png Size: 151x26
http://graphics7.nytimes.com/ads/marketing/mm07/nyt-logo.png Size: 151x26
http://graphics7.nytimes.com/ads/marketing/mm07/vertical_opinion.gif Size: 145x23
http://graphics7.nytimes.com/ads/marketing/mm07/vertical_opinion.gif Size: 145x23
http://up.nytimes.com/?d=0//&t=2&s=0&ui=&r=&u= Size: 3x1
/adx/bin/clientside/7e2e2078Q2FZkQ3F3VQ7BpQ27!l6c6L7cQ7BQ7Bpp82Q27Vp Size: 3x1
http://wt.o.nytimes.com/dcsym57yw10000s1s8g0boozt_9t1x/njs.gif?js=No&WT.tv=1.0.7 Size: 1x1
http://graphics7.nytimes.com/ads/ameriprise/AMP_logo_88x31.gif Size: 0x0
http://graphics7.nytimes.com/images/misc/nytlogo153x23.gif Size: 0x0
http://politics.nytimes.com/images/section/politics/elections/2008.gif Size: 0x0
http://graphics7.nytimes.com/adx/images/ADS/16/69/ad.166980/728x90_T_logo.gif Size: 0x0
http://graphics7.nytimes.com/adx/images/ADS/16/95/ad.169529/youngheart_88x31_8.gif Size: 0x0
http://graphics7.nytimes.com/adx/images/ADS/16/01/ad.160192/TMAG_86x60.gif Size: 0x0
http://graphics7.nytimes.com/ads/blank.gif Size: 0x0

Some of my assumptions above may seem less than ideal, but remember that it's good practice to include the width and height in the image tag so the browser knows how much visual space to leave while the page loads. For any well designed page this approach works nicely.

Another neat use for LINQ :)

UPDATE: you can download the code with my modifications and this sample from here.

ActionDisposable

Vijay Santhanam — Mon, 26 May 2008 04:32:17 GMT

I borrowed this class from the Wes Dyer's LINQ to ASCII Art post. It's a great way to return IDisposable from a method without creating a specialized class.

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

namespace System {

    public class ActionDisposable: IDisposable {

        Action action;

        public ActionDisposable(Action action) {

            this.action = action;

        public void Dispose() {

            action();

Wes uses ActionDisposable casually to reset Console properties. My example to demonstrate this class will be similar to Eilon Lipton's solution to locking a collection, expect I'll use ActionDisposable instead of specialized ReadLockDisposable and WriteLockDisposable.

public class SingletonSafeCollection<T>: Collection<T>

    private static readonly SingletonSafeCollection<T> instance = new SingletonSafeCollection<T>();

    public static SingletonSafeCollection<T> Instance {

get

            return instance;

    private ReaderWriterLockSlim rwLock = new ReaderWriterLockSlim();

    /// <summary>Acquires a read lock for reading the collection</summary>

    /// <returns>Disposable object that releases the read lock</returns>

    public IDisposable GetReadLock()

        rwLock.EnterReadLock();

        return new ActionDisposable(rwLock.ExitReadLock);

    /// <summary>Acquires a write lock for writing the collection</summary>

    /// <returns>Disposable object that releases the write lock</returns>

    public IDisposable GetWriteLock()

        rwLock.EnterWriteLock();

        return new ActionDisposable(rwLock.ExitWriteLock);

Now I can use the SingletonSafeCollection<T> anywhere in my code with guarantees that when I one takes a read lock, no one will be writing to the collection and when one takes a write lock, no one will be writing to the collection.

static void Main(string[] args)

    SingletonSafeCollection<int> numbers = SingletonSafeCollection<int>.Instance;

    using (numbers.GetWriteLock())

        // safe to write with a guarentee no one is reading or modifying the collection (except this thread)

        numbers.Add(1212);

    using (numbers.GetReadLock())

        // safe to read the list with a guarentee no one is modifying the collection

        numbers.ToList().ForEach(i => Console.WriteLine(i));

    Console.ReadLine();

LINQ & Lambda, Part 1: iTunes XML Querying

Vijay Santhanam — Sun, 04 May 2008 15:37:13 GMT

Today I was curious what my friend's favourite artists were. Rather than just ask him and give away any surprise of this years birthday present, I decided to sneakily scrape his iTunes library. He has a wide taste in music and buys a lot of it, so he's a great source of new music. His iTunes library is filled with interesting artists, songs and compilations. On the other hand, he's in the industry and collects a lot of amateur music. When looking for an ideal birthday gift idea in his iTunes library, I'll need to consider how much he plays any song.

iTunes keeps it's music metadata in an XML file for decorating music files with other metadata not supported in ID3 tags.

Using LINQ, there are two ways I could query this data:-

Use LINQ to XML.
Convert the DTD to XSD, generate proxy classes using LINQ to XSD and then query the loaded file with LINQ to Objects.

I *need* my LINQ & Lambda fix - now - so I'm going to the take the fast option numero uno. If anyone is interested in seeing LINQ to XSD in action, let me know in the comments.

Niel Bornstein's article on hacking the iTunes XML describes the DTD clearly. Even though his article is old, the key-value pair structure allows for the addition of new properties in newer iTunes versions.

If you've at least seen some XML before, simply perusing the file is enough to understand the simple format.

On Windows, you can find the library XML file in My Documents\My Music\iTunes\iTunes Music Library.XML
On OS X, it's in ~/Music/iTunes/iTunes Music Library.XML

Basically, the document root is a plist tag split up into three sections - header, track info and playlist info. Each section is within a dict tag, and each entity within the Track and Playlist sections are contained within dict tags.

The XML element for a track looks like :-

<key>839</key>
<dict>
  <key>Track ID</key><integer>839</integer>
  <key>Name</key><string>Sweet Georgia Brown</string>
  <key>Artist</key><string>Count Basie & His Orchestra</string>
  <key>Composer</key><string>Bernie/Pinkard/Casey</string>
  <key>Album</key><string>Prime Time</string>
  <key>Genre</key><string>Jazz</string>
  <key>Kind</key><string>Protected AAC audio file</string>
  <key>Size</key><integer>3771502</integer>
  <key>Total Time</key><integer>219173</integer>
  <key>Disc Number</key><integer>1</integer>
  <key>Disc Count</key><integer>1</integer>
  <key>Track Number</key><integer>3</integer>
  <key>Track Count</key><integer>8</integer>
  <key>Year</key><integer>1977</integer>
  <key>Date Modified</key><date>2004-06-16T18:10:55Z</date>
  <key>Date Added</key><date>2004-06-16T18:08:31Z</date>
  <key>Bit Rate</key><integer>128</integer>
  <key>Sample Rate</key><integer>44100</integer>
  <key>Play Count</key><integer>3</integer>
  <key>Play Date</key><integer>-1119376103</integer>
  <key>Play Date UTC</key><date>2004-08-17T16:39:53Z</date>
  <key>Rating</key><integer>100</integer>
  <key>Artwork Count</key><integer>1</integer>
  <key>File Type</key><integer>1295274016</integer>
  <key>File Creator</key><integer>1752133483</integer>
  <key>Location</key><string>file://localhost/Users/niel/Music/music.mp4</string>
  <key>File Folder Count</key><integer>4</integer>
  <key>Library Folder Count</key><integer>1</integer>
</dict>

To construct my query, I broke my goal into three tasks:

Find the collection of tracks.
For each song, find the play count and artist name.
Descendingly sort the song list by play count.
Select any artist only once.

And here's the code to write out my friends' favourite artists in descending order of popularity.

using System;
using System.IO;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Xml.Linq;
  
namespace iTunesXmlParser {
   class Program {

  
       static void Main(string[] args) {
                string xmlFile = args[1];
               using (var sr = new StreamReader(xmlFile)) {
                   var doc = XDocument.Load(sr);
  
                   // find the tracks dictionary
                   XElement tracksDictionary = (from element in doc.Descendants()
                                                where element.Value.Equals("Tracks")
                                                select element).First().NextNode as XElement;
  
                   // get all distinct track artist names ordered descendingly by track play count
                   // NOTE: if no play count exists for a track, the track is assumed to have 0 plays
  
                   List<string> artistNames = (from el in tracksDictionary.Descendants()
                                  let playCountValues = (from trackField in el.Descendants()
                                                         where trackField.Value == "Play Count"
                                                         select (trackField.NextNode as XElement))
                                  let artistValues = (from trackField in el.Descendants()
                                                         where trackField.Value == "Artist"
                                                         select (trackField.NextNode as XElement))
                                  where 
                                  el.Name.LocalName == "dict" // find the track key-value pair property set
                                  && artistValues.Count() > 0 // an artist property should exist
  
                                  orderby playCountValues.Count() == 0? 0 : Int32.Parse(playCountValues.First().Value) descending
                                  select artistValues.First().Value).Distinct().ToList();
  
                   Console.WriteLine("Number of artists:" + artistNames.Count());
  
                   // write out the artist names in decending order of popularity
                   foreach (var artistName in artistNames) {
                       Console.WriteLine(artistName);
                   }
               }
  
               Console.WriteLine("hit enter to exit");
               Console.ReadLine();
       }
   }
}

The let keyword allows you to define a variable within a query. In my case, the playCountValues and artistValues are the each IEnumerable<XElements> of the play count and artist name respectively. let is great for keeping variables that will be reused more than once elsewhere in the query.

This query is a bit complex and unusually long because the iTunes XML doesn't store key-values like <Name>DJ Shadow</Name> (the typical format). Notice the need to get the value element with (element.NextNode as XElement).

After running this on my friends library, the console spat out over 5000 lines of artist names. Success! Top of the list is "Zero 7". Second on the list is "DJ Shadow" - who I've never heard before. I'll definitely check these artists out.

The next thing I'll do is find out what albums of "Zero 7" he's got and perhaps cross reference the list with the an Amazon page to find an album he doesn't own. This years birthday present decision will be completely automated :)

Till next time on LINQ & Lambda, if there's any particular LINQ provider you want me to cover, please leave a message in the comments.

LINQ & Lambda

Vijay Santhanam — Sun, 04 May 2008 08:32:46 GMT

I think I have a problem. I'm addicted to LINQ and Lambdas...

Every opportunity I get to play with a new LINQ provider I take it. LINQ to XSD, LINQ to Lucene, LINQ to Flickr, LINQ to SQL, LINQ to * - you name it - I've ~~injected~~ used it.

And it seems I'm not the only one, with others confessing their uncontrollable attraction toward them too.

Last week I spent a few days on an old C# 2 project. Within minutes, I was clutching for the sweet, sweet 3.0 compiler. I couldn't stop sweating when writing event handler receivers like delegate(object sender, EventArgs e) {}.

Calm down Vijay... they're just withdrawal symptoms...

Oh the inner angst and turmoil! What do I do?! How do I expel the Demons from within?!

I call these demons LINQ & Lambda, and they've irrecoverably changed the way I think - reprogrammed my brain.

Last night, I dreamt of an anthropomorphism of these Demons.

Coincidentally, they resemble the evil, innocent looking, white-nationalist pop duo Prussian Blue.

Perhaps the best way to deal with them is to get the word out. Warn others of my folly and misadventure - in blog-series format.

Stay tuned for Part 1 of LINQ & Lambda...

A command line interface base class

Vijay Santhanam — Wed, 02 Jan 2008 19:51:38 GMT

I needed a simpler way build basic command line interfaces so I cobbled together a useful C# base class.

I made the class as simple as possible to create entry point (start up) classes.

class Program :BaseConsole {

    public override string Name {
        get { return "Console Application"; }
    }

    protected override void LoadCommands() {
        this.Commands.Add("print", () => Console.WriteLine("print out"));
        this.Commands.Add("another", () => Console.WriteLine("another print out"));
    }

    static void Main(string[] args) {
        new Program().Run();
    }
}

Just run a console application that starts the Main() of the Program class. Typing in any commands that have been added to Commands will invoke the associated action.

Console Application
=====================================
Type 'help' to get available commands
Type 'exit','done' or 'quit' to exit

>>print
print out

>>another
another print out

>>

If you type "help" it will print a list of available commands. You can exit the program by typing "exit","quit" or "done".

The commands themselves are stored in a Dictionary<string,Action> - the new lambdas in C# 3 make writing inline functions so simple.

Download it here.

A more useful UrlBuilder class

Vijay Santhanam — Tue, 01 Jan 2008 17:33:28 GMT

When I started my first ASP.NET project in 05, my URL building code included way too many string concatenations, String.Format calls and plain literals.

Being pre-MS-MVC days of typed URL construction via routing engines, I needed some code to make URL construction (particularly the query string) easier.

Then I found this UrlBuilder class. This is a great little class because it neatly derives from the framework UriBuilder class.

Since I started using it, I found it was inadequate when dealing with case sensitive HTTP servers. The specialized StringDictionary it uses lower-cases all keys and values.

To suit my needs, I modified the class in a few ways:

Upgraded to C# 3 - I think I'm addicted to lambda's so I involuntarily compiled it in .NET framework 3.5
The un-rendered query string is now stored as Dictionary<string,string> instead of StringDictionary which avoids casing problems
Provided overloads for ToString() casing - upper,lower or default (leaves casing alone)

Here's a simple example for building a Clickatell SMS sending URL.

UrlBuilder builder = new UrlBuilder("http://api.clickatell.com/http/sendmsg");
builder.QueryString["api_id"] = "23223";
builder.QueryString["user"] = "cutnpaste";
builder.QueryString["password"] = "ninja";
builder.QueryString["to"] = "61043678945";
builder.QueryString["text"] = "the message to send";
Console.WriteLine(builder.ToString(StringCaseDirection.Lower));

Download source code