Sanity Free dot org

A C# Command Line Args processing class

Thu, 31 Jan 2008 18:49:18 EST

The other day I was working on our video game's content server app. The way its set up is fairly complicated. It basically has 3 modes that it can run in (as a windows service, as a fully blown console shell, or as a windows application).

Being tired of writing long ugly blocks of code for command line arg's processing, I decided to build out an object (not at all like my last command line parser class) that would manage the command line args in an intuitive manner.

There are Three basic ways to use this class:

Sort of like a dictionary
With one big event handler
By registering specific event handlers

What I typically do is add the args that are passed into the main function into an arraylist or List<string> and simply ask if the list contains this switch or that switch:

static class Program {
    static void Main(string[] args) {
        List<string> cmdArgs = new List<string>(args);
        if(cmdArgs.Contains("/myswitch"))) {
            // ... whatever ...
        }
    }
}

As you can see, it still takes quite a bit of code. My first iteration of my CommandLineArgs class parsed out the command line switches and placed everything in a dictionary

static class Program {
    static void Main(string[] args) {
        CommandLineArgs cmdArgs = new CommandLineArgs();
        cmdArgs.IgnoreCase = true;
        // this adds a switch prefix regular expression used to determine what is a switch and what is not.
        // whats passed in is a normal Regex pattern.
        cmdArgs.PrefixRegexPatternList.Add("/{1}"); // /switch
        cmdArgs.PrefixRegexPatternList.Add("-{1,2}"); // --switch or -switch
        // once the args are parsed, the class strips off the switch prefix (here either / or - or --).
        cmdArgs.ProcessCommandLineArgs(args);
        if(cmdArgs.ContainsSwitch("myswitch"))) {
            // ... whatever ...
        }
    }
}

But that was pretty much just like using the list like I had been doing.

The next iteration added a SwitchMatch event so that when ProcessCommandLineArgs was called, as switches were parsed, it would kick of an event for each match, providing the switch name (minus the switch prefix) and the value of that switch.

static class Program {
    static void Main(string[] args) {
        CommandLineArgs cmdArgs = new CommandLineArgs();
        cmdArgs.IgnoreCase = true;
        cmdArgs.PrefixRegexPatternList.Add("/{1}");
        cmdArgs.PrefixRegexPatternList.Add("-{1,2}");
        cmdArgs.SwitchMatch += (sender, e) => {
            if(!e.IsValidSwitch) return
            switch(e.Switch) {
                case "foo": {
                    // ... handle the /foo -foo or --foo switch logic here ...
                } break;
            }
        };
        cmdArgs.ProcessCommandLineArgs(args);
    }
}

By the way, I'm using .NET 3.5 here (notice the nice lambda event handler there... yes, I am lazy and lambda's lend themselves nicely to how I do things) if you couldn't tell. If you're using .NET 1.1 or 2.0 then you can just create an event handler like you normally would.

This worked nicely. Only problem now is that I have to have the huge switch statement in my main class. So in the next iteration I decided it would be nice to be able to register specific switch handlers (one for "/foo", one for "--bar" and so on.

static class Program {
    static void Main(string[] args) {
        CommandLineArgs cmdArgs = new CommandLineArgs();
        cmdArgs.IgnoreCase = true;
        cmdArgs.PrefixRegexPatternList.Add("/{1}");
        cmdArgs.PrefixRegexPatternList.Add("-{1,2}");
        cmdArgs.RegisterSpecificSwitchMatchHandler("foo", (sender, e) => {
            // handle the /foo -foo or --foo switch logic here.
            // this method will only be called for the foo switch.
        });
        cmdArgs.ProcessCommandLineArgs(args);
    }
}

One other item I should also note is that there is also an InvalidArgs array too. On the events, there is an IsValidSwitch property that will let you know whether or not the switch is valid or not (since the SwitchMatch event is triggered whether or not the switch is valid) so if your command line contains any values that are not directly tied to a switch. For instance if you don't quote a string with spaces: /foo this is a string like this /foo "this is a string" then /foo's value will be "this" and is, a, string will all be contained in the invalid args list. If you use a switch prefix not accounted for in your prefix regex list, it will also be added to your InvalidArgs list (ex: yourapp.exe ^switch "values" both ^switch and values will be placed in your InvalidArgs list.

This class accepts the following formats:

<switch prefix>switch=value
<switch prefix>switch value

So in the spirit of sharing, here is my CommandLineArgs class:

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

public class CommandLineArgs {
    public const string InvalidSwitchIdentifier = "INVALID";
    List<string> prefixRegexPatternList = new List<string>();
    Dictionary<string, string> arguments = new Dictionary<string, string>();
    List<string> invalidArgs = new List<string>();
    Dictionary<string, EventHandler<CommandLineArgsMatchEventArgs>> handlers = new Dictionary<string, EventHandler<CommandLineArgsMatchEventArgs>>();
    bool ignoreCase = true;

    public event EventHandler<CommandLineArgsMatchEventArgs> SwitchMatch;

    public int ArgCount { get { return arguments.Keys.Count; } }

    public List<string> PrefixRegexPatternList {
        get { return prefixRegexPatternList; }
    }

    public bool IgnoreCase {
        get { return ignoreCase; }
        set { ignoreCase = value; }
    }

    public string[] InvalidArgs {
        get { return invalidArgs.ToArray(); }
    }

    public string this[string key] {
        get {
            if (ContainsSwitch(key)) return arguments[key];
            return null ;
        }
    }

    protected virtual void OnSwitchMatch(CommandLineArgsMatchEventArgs e) {
        if (handlers.ContainsKey(e.Switch) && handlers[e.Switch] != null ) handlers[e.Switch](this, e);
        else if (SwitchMatch != null ) SwitchMatch(this, e);
    }

    public void RegisterSpecificSwitchMatchHandler(string switchName, EventHandler<CommandLineArgsMatchEventArgs> handler) {
        if (handlers.ContainsKey(switchName)) handlers[switchName] = handler;
        else handlers.Add(switchName, handler);
    }

    public bool ContainsSwitch(string switchName) {
        foreach (string pattern in prefixRegexPatternList) {
            if (Regex.IsMatch(switchName, pattern, RegexOptions.Compiled)) {
                switchName = Regex.Replace(switchName, pattern, "", RegexOptions.Compiled);
            }
        }
        if (ignoreCase) {
            foreach (string key in arguments.Keys) {
                if (key.ToLower() == switchName.ToLower()) return true;
            }
        } else {
            return arguments.ContainsKey(switchName);
        }
        return false;
    }

    public void ProcessCommandLineArgs(string[] args) {
        for (int i = 0; i < args.Length; i++) {
            string value = ignoreCase ? args[i].ToLower() : args[i];
            foreach (string prefix in prefixRegexPatternList) {
                string pattern = string.Format("^{0}", prefix);
                if (Regex.IsMatch(value, pattern, RegexOptions.Compiled)) {
                    value = Regex.Replace(value, pattern, "", RegexOptions.Compiled);
                    if (value.Contains("=")) { // "<prefix>Param=Value"
                        int idx = value.IndexOf('=');
                        string n = value.SubString(0, idx);
                        string v = value.SubString(idx + 1, value.Length - n.Length - 1);
                        OnSwitchMatch(new CommandLineArgsMatchEventArgs(n, v));
                        arguments.Add(n, v);
                    } else { // "<prefix>Param Value"
                        if (i + 1 < args.Length) {
                            string @switch = value;
                            string val  = args[i + 1];
                            OnSwitchMatch(new CommandLineArgsMatchEventArgs(@switch, val));
                            arguments.Add(value, val);
                            i++;
                        } else {
                            OnSwitchMatch(new CommandLineArgsMatchEventArgs(value, null ));
                            arguments.Add(value, null );
                        }
                    }
                } else { // invalid arg ...
                    OnSwitchMatch(new CommandLineArgsMatchEventArgs(InvalidSwitchIdentifier, value, false));
                    invalidArgs.Add(value);
                }
            }
        }
    }
}

public class CommandLineArgsMatchEventArgs : EventArgs {
    string @switch;
    string value;
    bool isValidSwitch = true;

    public string Switch {
        get { return @switch; } 
    }

    public string Value {
        get { return value; }
    }

    public bool IsValidSwitch {
        get { return isValidSwitch; }
    }

    public CommandLineArgsMatchEventArgs(string @switch, string value)
        : this(@switch, value, true) { }

    public CommandLineArgsMatchEventArgs(string @switch, string value, bool isValidSwitch) {
        this.@switch = @switch;
        this.value = value;
        this.isValidSwitch = isValidSwitch;
    }
}

C# .NET Single Instance Application

Wed, 06 Jun 2007 20:35:32 EDT

Today I wanted to refactor some code that prohibited my application from running multiple instances of itself.

Previously I had use System.Diagnostics.Process to search for an instance of my myapp.exe in the process list. While this works, it brings on a lot of overhead, and I wanted something cleaner.

Knowing that I could use a mutex for this (but never having done it before) I set out to cut down my code and simplify my life.

In the class of my application main I created a static named Mutex:

static class Program {
    static Mutex mutex = new Mutex(true, "{8F6F0AC4-B9A1-45fd-A8CF-72F04E6BDE8F}");
    [STAThread]
    ...
}

By having a named mutex allows us to stack synchronization across threads and processes which is just the magic I'm looking for.

Mutex.WaitOne has an overload that specifies an amount of time for us to wait. Since we're not actually wanting to synchronizing our code (more just check if it is currently in use) we use the overload with two parameters: Mutex.WaitOne(Timespan timeout, bool exitContext). Wait one returns true if it is able to enter, and false if it wasn't. In this case, we don't want to wait at all; If our mutex is being used, skip it, and move on, so we pass in TimeSpan.Zero (wait 0 milliseconds), and set the exitContext to true so we can exit the synchronization context before we try to aquire a lock on it. Using this, we wrap our Application.Run code inside something like this:

static class Program {
    static Mutex mutex = new Mutex(true, "{8F6F0AC4-B9A1-45fd-A8CF-72F04E6BDE8F}");
    [STAThread]
    static void Main() {
        if(mutex.WaitOne(TimeSpan.Zero, true)) {
            Application.EnableVisualStyles();
            Application.SetCompatibleTextRenderingDefault(false);
            Application.Run(new Form1());
            mutex.ReleaseMutex();
        } else {
            MessageBox.Show("only one instance at a time");
        }
    }
}

So, if our app is running, WaitOne will return false, and we'll get a message box.

Instead of showing a message box, I opted to utilize a little Win32 to notify my running instance that someone forgot that it was already running (by bringing itself to the top of all the other windows). To achieve this I used PostMessage to broadcast a message to every window (that I had previously registered with RegisterWindowMessage) then my second instance exits. The running application instance would receive that notification and process it. In order to do that, I overrode WndProc in my main form and listened for my custom notification. When I received that notification I set the form's TopMost property to true to bring it up on top.

Here is what I ended up with:

Program.cs

static class Program {
    static Mutex mutex = new Mutex(true, "{8F6F0AC4-B9A1-45fd-A8CF-72F04E6BDE8F}");
    [STAThread]
    static void Main() {
        if(mutex.WaitOne(TimeSpan.Zero, true)) {
            Application.EnableVisualStyles();
            Application.SetCompatibleTextRenderingDefault(false);
            Application.Run(new Form1());
            mutex.ReleaseMutex();
        } else {
            // send our Win32 message to make the currently running instance
            // jump on top of all the other windows
            NativeMethods.PostMessage(
                (IntPtr)NativeMethods.HWND_BROADCAST,
                NativeMethods.WM_SHOWME,
                IntPtr.Zero,
                IntPtr.Zero);
        }
    }
}

NativeMethods.cs

// this class just wraps some Win32 stuffthat we're going to use
internal class NativeMethods {
    public const int HWND_BROADCAST = 0xffff;
    public static readonly int WM_SHOWME = RegisterWindowMessage("WM_SHOWME");
    [DllImport("user32")]
    public static extern bool PostMessage(IntPtr hwnd, int msg, IntPtr wparam, IntPtr lparam);
    [DllImport("user32")]
    public static extern int RegisterWindowMessage(string message);
}

and

Form1.cs (front side partial)

public partial class Form1 : Form {
    public Form1() {
        InitializeComponent();
    }
    protected override void WndProc(ref Message m) {
        if(m.Msg == NativeMethods.WM_SHOWME) {
            ShowMe();
        }
        base.WndProc(ref m);
    }
    private void ShowMe() {
        if(WindowState == FormWindowState.Minimized) {
            WindowState = FormWindowState.Normal;
        }
        // get our current "TopMost" value (ours will always be false though)
        bool top = TopMost;
        // make our form jump to the top of everything
        TopMost = true;
        // set it back to whatever it was
        TopMost = top;
    }
}

Fun at the office

Fri, 20 Apr 2007 00:24:49 EDT

The windows in our office building (the windows I sit right in front of) look directly out over Campbell road in Richardson. Its a fairly busy road (three lanes on each side). The company relocated to this office space around March of last year. Since that time we've seen people run into light poles, get in a few finder binders, and come really close to smashing each other to bits, but today took the cake.

Around 5:30 or 6:00 PM people are quietly working away trying to wrap things up, or playing a round of pinball at the office pinball machine, when all of the sudden you hear a really loud BOOM out on the street. There was no screeching tires, no horns honking, just a loud thunderous crash sound. Our office is one big room, everybody sits at tables looking at everyone else, and we all popped up to take a look outside.

All three lanes headed east are bumper to bumber. There seems to be four or five cars seemingly fused together. There's a large SUV (I'm guessing a ford explorer) missing most of its "what used to be a hood / engine area of the car", the guy inside is hidden behind a wall of air bags. Four cars seemingly fused together (at first it looked like much more because of all the traffic) end to end.

The poor sod at the back was the red SUV. He had plowed into the back end of a huge suburban, who had then managed to get up under the bumper of the buick sedan in front of her, who then ate the back end of a nissan.

The gal in front faired the best with what looked like a banged up rear bumper.

The buick sedan who was next was firmly supplanted on the hood of the suburban looked to be done in.

The suburban looked pretty much unscathed except for the transmission fluid which was now starting to leak from the car at an alarming rate. It had taken the brunt of the (assumingly) 45 MPH impact of the SUV. I can only imagine what would have happened to that poor buick had the suburban not been between them. The force of the impact was so strong that it had smashed the Suburban's transmission causing what looked like a large pool of blood (transmission fluid is red) to seep from beneath it.

The people involved started to get out of their vehicles (except the guy in the SUV) and try to figure out what the heck just happened. It was a while before anyone made any calls on their mobile phones (like to call the police), but the Richardson police have a pretty heavy presence on that road and it wasn't long before there were teams of cops blocking off traffic and getting things sorted.

That pretty much killed the rest of our work day, and provided us with some (albeit morbid) entertainment.

I snapped a photo with my phone (which totally doesn't do it justice, but its a crappy RAZR and the shots where I zoomed in, ended up actually just being cropped pics of this one).

Creating Fake Enums

Wed, 04 Apr 2007 19:15:58 EDT

In .NET enums are a strongly typed flag-like object. Flags would normally defined as a macro, or constant variable. The trouble with typical numeric flags is that a) the coder using the flag may or may not know all of the possible values, or b) might accidentally type the wrong constant or macro. Since the flag is just some magic number they may end up with a logic error that may be hard to find under certain circumstances. With enums I can provide the same logic (some numeric flag) but create a type that I can use to enforce some subset of numbers that are checked at compile time, and can be verified at run time ( Enum.IsDefined ). As with everything, enums have their faults. What if I want to extend some enum object (polymorphic enums?), or give it additional functionality or meta data. Yesterday at work we ran across a case where being able to extend an enum was mandatory. All of our enums have numeric and string values, and are typically written like:

public enum Foo {
    [FriendlyName("One Foo")]
    One = 1,
    [FriendlyName("Two Foo")]
    Two = 2,
    [FriendlyName("Three Foo")]
    Three = 3
}

the FriendlyName attribute enables you to have both a numeric flag value as well as some human readable value of the enum element other than "One" or "Two" or "SomeEnumValue"(ie: Foo.One.ToString())

Our company uses code generation like most fish use water. We use enums quite a bit and each enum type and all of their values are stored in a database which is used by the code generation tool to generate 99% of our business and data layer code. Since our code is generated, if we go in and manually add additional values that don't need to be stored in the database, our generation tool will blow away any hand written changes on every build. We would have killed to have something like a partial enum, but alas, no such thing exists.

I set out to try to create a "Fake Enum" class that acted and felt like an enum but allowed us to extend it by way of the partial class or inheritance. Well after a little poking around, inheritance flew out the window (just over complex without resorting to some generics base type), but the ability to do a partial fake enum was definitely doable.

Here's the code I came up with:

using System;
using System.ComponentModel;
using System.Globalization
using System.Reflection;

[TypeConverter(typeof(FakeEnum.FakeEnumConverter))]
public partial class FakeEnum {

    // typical "Enum" declarations, sort of like One = 1, Two = 2, Three
    public static readonly FakeEnum One = new FakeEnum(1, "One's Friendly Name");
    public static readonly FakeEnum Two = new FakeEnum(2, "Two's Friendly Name");
    public static readonly FakeEnum Three = new FakeEnum(3, "Three's Friendly Name");
    public static readonly FakeEnum Four = new FakeEnum(4);
    public static readonly FakeEnum Five = new FakeEnum(5);
    public static readonly FakeEnum Six = new FakeEnum(6);


    // implementation to provide "Enum" like functionality
    int value;
    string friendlyName;

    public string FriendlyName { get { return friendlyName; } }

    public override string ToString() {
        return ToString("");
    }

    public virtual string ToString(string format) {
        foreach(FieldInfo staticField in GetType().GetFields(BindingFlags.Static | BindingFlags.Public | BindingFlags.FlattenHierarchy)) {
            FakeEnum temp = staticField.GetValue(null) as FakeEnum;
            if(temp == null) continue;
            if(temp.value == value) {
                switch(format) {
                    case "fn": {
                        return temp.friendlyName;
                    }
                    default: {
                        return staticField.Name;
                    }
                }
            }
        }
        return base.ToString();
    }

    public override int GetHashCode() {
        return value.GetHashCode();
    }

    public override bool Equals(object obj) {
        if(object.ReferenceEquals(obj, null)) return false;
        FakeEnum temp = obj as FakeEnum;
        if(!object.ReferenceEquals(temp, null)) {
            return temp.value == value;
        } else {
            return false;
        }
    }

    public static object Parse(Type type, int value) {
        foreach(FieldInfo fieldInfo in type.GetFields(BindingFlags.FlattenHierarchy | BindingFlags.Static | BindingFlags.Public)) {
            FakeEnum enumValue = fieldInfo.GetValue(null) as FakeEnum;
            if(enumValue != null) {
                if(enumValue.value == value) {
                    return enumValue;
                }
            }
        }
        throw new ArgumentException(string.Format("{0} is not defined in {1}", value, type.Name));
    }

    public static object Parse(Type type, string value) {
        return Parse(type, value, false);
    }

    public static object Parse(Type type, string value, bool ignoreCase) {
        if(string.IsNullOrEmpty(value)) throw new ArgumentNullException("value was either null or empty");
        foreach(FieldInfo field in type.GetFields(BindingFlags.Public | BindingFlags.Static | BindingFlags.FlattenHierarchy)) {
            bool isMatch = false;
            if(ignoreCase) {
                isMatch = StringComparer.InvariantCultureIgnoreCase.Compare(field.Name, value) == 0;
            } else {
                isMatch = StringComparer.InvariantCulture.Compare(field.Name, value) == 0;
            }
            if(isMatch) {
                FakeEnum temp = field.GetValue(null) as FakeEnum;
                if(temp == null) throw new InvalidOperationException(string.Format("{0} not convertable to {1}", type, typeof(FakeEnum)));
                object instance = Activator.CreateInstance(type, new object[] { temp.value, temp.friendlyName });
                return instance;
            }
        }
        throw new ArgumentException(string.Format("{0} is not defined in {1}", value, type.Name));
    }

    public static bool IsDefined(Type type, object value) {
        if(object.ReferenceEquals(value, null)) throw new ArgumentNullException("value");
        if(typeof(FakeEnum).IsAssignableFrom(type)) {
            return IsDefined(type, ((FakeEnum)value).value);
        }
        return false;
    }

    public static bool IsDefined(Type type, int value) {
        foreach(FieldInfo staticField in type.GetFields(BindingFlags.Static | BindingFlags.Public | BindingFlags.FlattenHierarchy)) {
            object temp = staticField.GetValue(null);
            if(temp == null) continue;
            if(typeof(FakeEnum).IsAssignableFrom(type)) {
                if(((FakeEnum)temp).value == value) return true;
            }
        }
        return false;
    }

    public static bool IsDefined(Type type, string value) {
        return IsDefined(type, value, false);
    }

    public static bool IsDefined(Type type, string value, bool ignoreCase) {
        foreach(FieldInfo staticField in type.GetFields(BindingFlags.Static | BindingFlags.Public | BindingFlags.FlattenHierarchy)) {
            bool isMatch = false;
            if(ignoreCase) {
                isMatch = StringComparer.InvariantCultureIgnoreCase.Compare(staticField.Name, value) == 0;
            } else {
                isMatch = StringComparer.InvariantCulture.Compare(staticField.Name, value) == 0;
            }
            if(isMatch) return true;
        }
        return false;
    }

    public static explicit operator FakeEnum(int value) {
        foreach(FieldInfo staticField in typeof(FakeEnum).GetFields(BindingFlags.Public | BindingFlags.Static | BindingFlags.FlattenHierarchy)) {
            FakeEnum temp = staticField.GetValue(null) as FakeEnum;
            if(temp == null) continue;
            if(temp.value == value) return temp;
        }
        return null;
    }

    public static explicit operator int(FakeEnum fakeEnum) {
        return fakeEnum.value;
    }

    public static implicit operator FakeEnum(string value) {
        if(string.IsNullOrEmpty(value)) return null;
        foreach(FieldInfo field in typeof(FakeEnum).GetFields(BindingFlags.Public | BindingFlags.Static | BindingFlags.FlattenHierarchy)) {
            if(StringComparer.InvariantCultureIgnoreCase.Compare(field.Name, value) == 0) {
                FakeEnum temp = field.GetValue(null) as FakeEnum;
                if(temp == null) throw new InvalidOperationException(string.Format("{0} not convertable to {1}", value, typeof(FakeEnum)));
                FakeEnum instance = new FakeEnum(temp.value, temp.friendlyName);
                return instance;
            }
        }
        return null;
    }

    public static bool operator == (FakeEnum a, FakeEnum b) { 
        return a.Equals(b);
    }

    public static bool operator != (FakeEnum a, FakeEnum b) { 
        return !a.Equals(b);
    }

    protected FakeEnum(int value) : this(value, null) { }

    protected FakeEnum(int value, string friendlyName) {
        this.value = value;
        this.friendlyName = friendlyName;
        if(string.IsNullOrEmpty(friendlyName)) {
            this.friendlyName = ToString();
        }
    }

    public class FakeEnumConverter : TypeConverter {
        public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value) {
            if(value is string) {
                return (FakeEnum)((string)value);
            }
            return base.ConvertFrom(context, culture, value);
        }
    }
}

Since we were generating these guys, we'd put the class implementation in one file, and our enum like declarations in another. It made it look a bit more "enum" like.

From there, you can use it just like a normal enum except that you now have a built in friendly name that you can access:

public void MyMethod(FakeEnum flag) {
    switch(flag) {
        case FakeEnum.One: {
            Console.WriteLine(flag.FriendlyName);
        }
    }
}

Since additional partial classes would be added, I didn't want to have to provide some functionality of ToString or explicit conversion for each partial class, so I resolved the ability to get the numeric value, string member name value through reflection. Since I had full control over the type, I decided it would be nice to add the FriendlyNameAttribute functionality into my fake enum, so I did.

Its implementation uses .net reflection to iterate over its members and obtain the enum like member and its associated and values (since every member we use like an enum will be a static instance of itself) and additionally its friendly name. actually we could make our fake enum non-numeric based (this would kind of defeat the ability to do a flag like operation) but that wasn't something needed at the time so we just stuck with int.

To be able to use these objects like a bit field (like enums are), one would need to add the | and & operators so that fields could be combined or extracted (perhaps if I'm bored I'll add this to a future version).

Vista

Wed, 21 Feb 2007 01:57:54 EST

I've needed a new monitor for a while now, but have been putting it off... My current monitor is getting so hard to read so I decided it was finally time to break down and get a new one. With that purchase I decided I may as well pick up vista, so I did. We're making the upgrade at work later this week too, so I figured I'd push it at home as well.

Tonight I was looking around at the vista section of microsoft.com, and I noticed a chart that described the upgrade path for various operating systems migrating to vista. Wouldn't you know it, xp x64's (the OS I run here at home) upgrade path is a "clean install"

Man I just love microsoft... I may as well "upgrade" to a mac! What a bunch of crap!

C# 3.0 Lambda expressions

Tue, 13 Feb 2007 13:51:13 EST

I've finally seen the light for these little buggers. As I wrote in my original post that I really didn't glean much from the description of lambda expressions that are mentioned in the specification, but I ran across a great article on it on the code project that did a really good job at explaining it.

So my meta blog for the day is a link to that article:

» http://www.codeproject.com/csharp/lambdaexpressions.asp

Phalanger, PHP for .NET

Fri, 26 Jan 2007 12:57:22 EST

I ran across an article on the code project about a PHP compiler / language extension for .NET.

PHP has an extension for .NET that allows you to use .NET resources in PHP code, but this allows you to use PHP from .NET, with support for native PHP API's as well as managed compilation. This project may end up making my article on nusoap & C# obsolete, though it should make writing web services in PHP as easy as it is in C#.

» Phalanger Home
» Code Project Article

my new years resolution

Wed, 17 Jan 2007 17:07:32 EST

Well, for the longest time I resolved every new year, never to make a new years resolution. That was very successful for quite some time, so I have a nearly perfect record. This year, I decided I was getting way to inactive, so I decided to buy a membership to a gym.

When I was in high school, I was on the swim and diving team. I'd typically warm up by swimming 500 meters, then do various types of strokes / kicks for about 2000 meters, then warm down with another 500 meters. I signed up at a particular gym because there was a facility near my work and home, and they both had pools. I figured I could swim at lunch from work, and after work near home.

Last night I swam for about an hour (probably closer to 45 minutes) and after 100 meters, my arms felt like they were (jelly, and) about to fall off. It took me the rest of that hours time to finish swimming something close to a 500 meters... It was after the 100 meters when my arms lost all strength that I realized how far I'd really gone. All the pictures of me looking like a whale had somehow gotten past my "fat" radar, but my first 100 meters in the pool caused a huge blip. That night when I got home and had to do two breathing treatments for my asthma because it was such a shock to my system. I got home around 8 pm and it wasn't till about 10 that my heart rate got back to normal.

This afternoon I went at it again. This time I was able to swim much longer without folding up. Minutes after I got out of the pool my heart rate went back to normal, and my asthma didn't act up. So hopefully it gets easier as time goes on.

.NET Reflection

Sat, 06 Jan 2007 03:29:49 EST

What is reflection? Its the image we seen in a mirror. In .NET however its a system that lets you do at runtime what you would normally do in a text editor or visual studio.

Like most object oriented programming languages, .net has the concept of a "type." a Type defines what an object is. Whether your using a primitive such as an integer, or a complex data type, each thing in .net has a type that corresponds to what it is.

public class Foo {}

This class is of type Foo. Now this class is basically pointless... Why? Well because it has no members. Actually it does have members because everything inherits from System.Object, and System.Object has 12 member methods some have overloads, some are static, some are private some are protected others are public. For the sake of simplicity, we wont discuss System.Object, but will stick only to Foo.

public class Foo {
    private int a;
}

Typically we'd never have a class that looked like this. After all, the complier would never let us access Foo::a because it is a private member. What does this have to do with reflection you may ask yourself? The rules of the compiler do not apply to reflection.

To understand reflection, you need to understand what a class is, how encapsulation works (what access modifiers are), what a function is and what variables are. We could go a little further, but thats a good starting point.

Lets take our previous class declaration and spice it up a bit.

public class Foo {
    private int a;

    public int A { 
        get { return a; }
        set { a = value; }
    }

    public bool Bar(string input) {
        return input == "Baz";
    }

    protected void Bing() {
        Console.WriteLine("I'm not very creative");
    }    

    public Foo() { }
}

I've given Foo a makeover. It now has a private variable, a public property, a public and a protected method and a constructor. I've given Foo a few "members."

On the surface (which I wont scratch much) reflection allows you to access, modify or invoke members of an object.

In our editor we can do this very easily:

Foo f = new Foo();
bool b = f.Bar("Baz");

So lets look at what we're doing here.

Where does Foo come from?

At the top (or bottom, depending on your endianness) of the Reflection world is the Assembly (a dll or exe). .NET assemblies are files that (can) contain namespaces and classes. Each assembly contains a manifest (aka a list) of other assemblies that it references. It also contains info about what classes it contains.

When a .NET application starts up, the framework spiders out and loads each assembly in each referenced assembly's manifest until everything referenced is loaded into the current AppDomain. If Foo happens to be in one of these dll's then everything is fine, but what if it isn't? Lets start there. The AppDomain object contains a list of all loaded "Assemblies" (if you cared to look at whats loaded).

Assembly[] asms = AppDomain.CurrentDomain.GetAssemblies();

if an assembly is not loaded, we can load it ourselves (unlike other technologies, once an assembly is loaded into the app domain, it cannot be unloaded until the app domain is unloaded).

Assembly fooAsm = Assembly.LoadFile(@"C:\My Path\foo.dll");

The Assembly object represents the actual dll or exe file and all that is contained within it. From it, we can get a list of types that the assembly contains:

Type[] types = fooAsm.GetTypes();

or request a particular type:

Type fooType = fooAsm.GetType("Foo");

if fooAsm did not contain a class named "Foo" then GetType would return null.

So, now we've loaded the dll / assembly that contained our class, and we've gotten a Type object that contains information about the class Foo. From fooType, we can get a list of Foo's members:

MemberInfo[] memberInfo = fooType.GetMembers();

MemberInfo is the base class for other member specific things like fields, methods, properties and constructors. MemberInfo has a property named "Name" which will match the name you give the member at the source code level (variable a, property A, method Bar, and constructor Foo). The System.Type object can also be used to get specific types of members like fields, methods, constructors and properties.

MethodInfo[] methods = fooType.GetMethods();
PropertyInfo[] properties = fooType.GetProperties();
FieldInfo[] fields = fooType.GetFields();
ConstructorInfo[] constructors = fooType.GetConstructors();

These objects contains more member specific info, such as method parameters, and return type, whether the property has a get and set or just a getter. Each of these Get...() methods also has an overload that takes a BindingFlags parameter. BindingFlags are things that must be considered when looking for a member. if we use the GetMember(field,property,method or constructor) that takes a string, it will look for a member who's name matches that. Reflection uses more than just the name to find the member that you're requesting, the binding flags give additional info as to the members access modifier (public / non-public), whether it's an instance member or a static member, and so on.

FieldInfo aField = fooType.GetField("a", BindingFlags.NonPublic | BindingFlags.Instance);

In the above code, I get a FieldInfo object which represents the private int variable "a" and I can do the same with the method Bar, the parameterless constructor and the property.

Great right? Who the heck cares? What does this have to do with the price of tea? Lets see...

When we simply wrote the code:

Foo f = new Foo();

the compiler had to locate the assembly that contains foo, load the foo type and create an instance. so lets do the same, but using reflection.

Assembly fooAsm = Assembly.LoadFile(@"C:\My Path\foo.dll");
Type fooType = fooAsm.GetType("Foo");
object foo = Activator.CreateInstance(fooType);

Keep in mind that when we load the assembly at runtime, we cannot simply do:

Foo f = (Foo)Activator.CreateInstance(fooType);

unless we add a reference to foo.dll inside visual studio or in our command line compile statement. If we did that, then we don't need to use reflection. We simply need an instance of foo. At the time we code it, we don't care what its type actually is. We know we have an instance of it, and can invoke its methods, access its properties and set its members through reflection (using the MemberInfo, MethodInfo, PropertyInfo, FieldInfo's that we get from its Type object). With reflection, the boundaries of encapsulation no longer apply (but should still be respected). We can access internal objects, we can access and manipulate private class members, or invoke private methods. Back to the matter of creating the instance of foo... One thing to keep in mind about using Activator.CreateInstance is that it actually uses the objects constructor to create the instance that gets returned, so if you CreateInstance as I have above, make sure you have a parameterless constructor in your class. Otherwise, you'll also have to pass in the constructor args as the second set of parameters after the System.Type in CreateInstance.

now lets imagine something crazy that we want to do:

Foo foo = new Foo();
foo.a = 32;

we could never write code that would do this unless it was inside a member (method or property) of Foo (a is a private member and therefore isnt accessible externally to Foo).

Assembly fooAsm = Assembly.LoadFile(@"C:\My Path\foo.dll");
Type fooType = fooAsm.GetType("Foo");
object foo = Activator.CreateInstance(fooType);
FieldInfo fooFieldA = fooType.GetField("a", BindingFlags.NonPublic | BindingFlags.Instance);
fooFieldA.SetValue(foo, 32);
int aVal = (int)fooFieldA.GetValue(foo);

so in the above code, we loaded the foo.dll, got the type that we were looking for (Foo), created an instance of it (using Activator.CreateInstance), got the field that we wanted to set, and used the FieldInfo object to set that field in our instance. then for good measures, we got the value that we just set using that field info object.

Each of the derived objects of MemberInfo (MethodInfo, FieldInfo, PropertyInfo, ConstructorInfo, EventInfo) all use the same concepts. First, you obtain an instance of the object you wish to reflect upon, then you obtain the XXXXInfo object that represents the member you want to manipulate, then you use that object to get, set, invoke or handle whatever your trying to do. That necessitates having a valid instance (which you have) and thats pretty much the basics of using reflection.

This has been an end to end application of the use of reflection. It is not meant as a style guide in how you use reflection. You may very well know everything about the type you're reflecting upon. In that instance, you may just want to reflectively invoke a method, or set a property. You may actually want to modify the look and feel or a Windows control which provides no public means of achieving what you wish to achieve.

Here's a little parting sample using the reflection to access an modify various parts of Foo.

Assembly fooAsm = Assembly.LoadFile(@"C:\My Path\foo.dll");
Type fooType = fooAsm.GetType("Foo");
object foo = Activator.CreateInstance(fooType);
MethodInfo barMethod = fooType.GetMethod("Bar", BindingFlags.Public | BindingFlags.Instance);
// invoke ( instance, method parameters );
bool isBar = barMethod.Invoke(foo, new object[] { "Baz" });

MethodInfo bingMethod = fooType.GetMethod("Bing", BindingFlags.NonPublic | BindingFlags.Instance);
bingMethod.Invoke(foo, null);

PropertyInfo propertyA = fooType.GetProperty("A", BindingFlags.Public | BindingFlags.Instance);
propertyA.SetValue(foo, 33);
int aVal = propertyA.GetValue(foo, null); // second parameter is for if the property was in indexer

All of which equates to the following lines of code:

Foo foo = new Foo();
bool isBar = foo.Bar("Baz");
foo.Bing();
foo.A = 33;
int aVal = foo.A;

If you have any questions, comments, or felt that this article was missing any crucial information, please register (its free) in the FORUMS and post your thoughts there.

Standard CRC 16 in C#

Fri, 15 Dec 2006 17:23:45 EST

I've been working on a service at work that will end up being this big cluster of servers that all talk with each other. One of the things I needed was a small crc checksum for some of the more compact UDP messages that get sent around. I thought about just using the CRC16-CCITT library I already had, but decided on using the standard CRC16 algorithm. Since I posted the CRC32 and CRC16-CCITT implementations I thought I'd post this one too.

using System;

public class Crc16 {
    const ushort polynomial = 0xA001;
    ushort[] table = new ushort[256];

    public ushort ComputeChecksum(byte[] bytes) {
        ushort crc = 0;
        for(int i = 0; i < bytes.Length; i++) {
            byte index = (byte)(crc ^ bytes[i]);
            crc = (ushort)((crc >> 8) ^ table[index]);
        }
        return crc;
    }

    public byte[] ComputeChecksumBytes(byte[] bytes) {
        ushort crc = ComputeChecksum(bytes);
        return new byte[] { (byte)(crc >> 8), (byte)(crc & 0x00ff) };
    }

    public Crc16() {
        ushort value;
        ushort temp;
        for(ushort i = 0; i < table.Length; i++) {
            value = 0;
            temp = i;
            for(byte j = 0; j < 8; j++) {
                if(((value ^ temp) & 0x0001) != 0) {
                    value = (ushort)((value >> 1) ^ polynomial);
                }else {
                    value >>= 1;
                }
                temp >>= 1;
            }
            table[i] = value;
        }
    }
}

If you need for this code to be CLS compliant, you can change the method signature's return type from ushort to int and it will operate the same (the ushort crc value will be implicitly converted from ushort to int)

Links to the other C# CRC implementations CRC16-CCITT, CRC32

CRC 16 CCITT in C#

Wed, 08 Nov 2006 03:32:03 EST

Once again I found myself needing another type of CRC algorithm in C#. I found one on code project, but their implementation of CRC 16 CCITT didn't produce that checksum I needed. Come to find out there are different methods to calculate CRC 16 CCITT which use different initial values for the crc.

I ended up writing this one for my own purposes:

using System;

public enum InitialCrcValue { Zeros, NonZero1 = 0xffff, NonZero2 = 0x1D0F }

public class Crc16Ccitt {
    const ushort poly = 4129;
    ushort[] table = new ushort[256];
    ushort initialValue = 0;

    public ushort ComputeChecksum(byte[] bytes) {
        ushort crc = this.initialValue;
        for(int i = 0; i < bytes.Length; i++) {
            crc = (ushort)((crc << 8) ^ table[((crc >> 8) ^ (0xff & bytes[i]))]);
        }
        return crc;
    }

    public byte[] ComputeChecksumBytes(byte[] bytes) {
        ushort crc = ComputeChecksum(bytes);
        return new byte[] { (byte)(crc >> 8), (byte)(crc & 0x00ff) };
    }

    public Crc16Ccitt(InitialCrcValue initialValue) {
        this.initialValue = (ushort)initialValue;
        ushort temp, a;
        for(int i = 0; i < table.Length; i++) {
            temp = 0;
            a = (ushort)(i << 8);
            for(int j = 0; j < 8; j++) {
                if(((temp ^ a) & 0x8000) != 0) {
                    temp = (ushort)((temp << 1) ^ poly);
                } else {
                    temp <<= 1;
                }
                a <<= 1;
            }
            table[i] = temp;
        }
    }
}

This was used for testing during the time we were looking at the Battlefield 2142 auth token, and were trying to figure out what the last 2 bytes of that token were made of. Battlefield 2142's auth token uses the CRC 16 CCITT with the initial value of 0 (new Crc16Ccitt(InitialCrcValue.Zeros) in the above class.

If you need for this code to be CLS compliant, you can change the method signature's return type from ushort to int and it will operate the same (the ushort crc value will be implicitly converted from ushort to int)

Links to the other C# CRC implementations CRC32, CRC16

A Generic Singleton Pattern in C#

Wed, 04 Oct 2006 14:51:56 EDT

I don't know why its never occured to me to implement the singleton pattern as a generic type before. I've always just created the singleton pattern as part of my class (not that we're talking about a lot of coding here), but it occured to me that a singleton could be a lot easier to implement and spot if I used a generic type.

Here is my generic Singleton class:

public static class Singleton<T> where T : new()
{
    static Mutex mutex = new Mutex();
    static T instance;
    public static T Instance
    {
        get
        {
            mutex.WaitOne();
            if(instance == null)
            {
                instance = new T();
            }
            mutex.ReleaseMutex();
            return instance;
        }
    }
}

Now, instead of implementing this same thing in every single class you want to act as a singleton, you simply use the generic definition: Foo.Instance.Whatever turns into Singleton<Foo>.Instance.Whatever.

Now, this doesnt keep you from creating non singleton objects of whatever type you have (there may still be some clever way to do that, but I'm not familiar with it), but it does save you the time of implementing the singleton pattern on singleton objects.

Triple DES between PHP and C#

Thu, 28 Sep 2006 04:17:32 EDT

The past while at work I've been working through some annoyingly overcomplicated encryption issues. The problem is not that Triple DES is all that complicated or annoying, it's just that when you have 2 different technologies (one doing the encrypting and one doing the decrypting) at work; it can be frustrating to get anything accomplished.

Our issues stemmed around the fact that we were using .NET 1.1 and they were using Java (with the standard crypto providers). There are a few subtleties between Microsoft's crypto providers and Java's. .NET provides 3 (ok, really only 2) Padding modes, and Java provides like 5, but they don't provide any in common. One easy padding mode is to append 0x00 bytes to the end of the final block to make it an even 64 bits wide. The Java provider didn't have this, but its easy enough to add ( by appending null char's '\0' to the end of the string then calling getBytes() ). So that's the route we took. After overcoming a few problems with "How do we encode our bytes used for the key and IV and still be compatible" we were off and running.

That made me wonder how compatible PHP and .NET's 3DES were. Since I didn't see any "Padding Mode" for PHP's, I simply hand coded the padding the same way we did with the Java code.

Here's my php script:

<?php

if(!isset($_POST['op'])) {
    ?>
<form id="form1" name="form1" method="post" action="">
  enter text
  <input name="data" type="text" />
  <input type="hidden" value="op" name="op" />
  <input type="submit" name="Submit" value="Submit" />
</form>
    <?php
}else {
    $buffer = $_POST['data']; 
    // get the amount of bytes to pad
    $extra = 8 - (strlen($buffer) % 8);
    // add the zero padding
    if($extra > 0) {
        for($i = 0; $i < $extra; $i++) {
            $buffer .= "\0";
        }
    }
    // very simple ASCII key and IV
    $key = "passwordDR0wSS@P6660juht";
    $iv = "password";
    // hex encode the return value
    echo "Result: ".bin2hex(mcrypt_cbc(MCRYPT_3DES, $key, $buffer, MCRYPT_ENCRYPT, $iv));	
}
?>

Then entered in my text (in this case I used "Test" in both)

Then I wrote up a sample in .NET to try to see if we had to massage the data or not:

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

namespace TestBed {
    class Program {
        static void Main(string[] args) {
            byte[] key = Encoding.ASCII.GetBytes("passwordDR0wSS@P6660juht");
            byte[] iv = Encoding.ASCII.GetBytes("password");
            byte[] data = Encoding.ASCII.GetBytes("Test");
            byte[] enc = new byte[0];
            TripleDES tdes = TripleDES.Create();
            tdes.IV = iv;
            tdes.Key = key;
            tdes.Mode = CipherMode.CBC;
            tdes.Padding = PaddingMode.Zeros;
            ICryptoTransform ict = tdes.CreateEncryptor();
            enc = ict.TransformFinalBlock(data, 0, data.Length);
            Console.WriteLine(Bin2Hex(enc));
            Console.ReadLine();
        }
        // my bin2hex implementation		
        static string Bin2Hex(byte[] bin) {
            StringBuilder sb = new StringBuilder(bin.Length * 2);
            foreach(byte b in bin) {
                sb.Append(b.ToString("x").PadLeft(2, '0'));
            }
            return sb.ToString();
        }
    }
}

"47794945c0230c3d" Wouldn't you know it! It worked like a charm!

Would have been nice if the Java -> .NET solution had been that easy.

battlefield 2142

Wed, 20 Sep 2006 15:03:23 EDT

I took the dive (got a kitchen pass from the wife) and pre-ordered Battlefield 2142 yesterday! I cant wait, 19 some odd days left (from when I wrote this). I guess since I'll download it and play it the moment its released, I should just go ahead and take the day off to play it all day... (I can always dream anyway).

Surreal!

Mon, 28 Aug 2006 01:43:11 EDT

We've been in the middle of the biggest drought Dallas has seen in a long time. Every day has over 100°F and my asthma's been killing me. My water bill has been only a little bit less expensive my mortgage payment lately, and every time it rains (uhm, I mean both times it's rained, [this summer]), the rain seems to hover about 2 feet off the ground just before it runs off down the gutter. It's so dry my boss recently lost a golf ball down a crack in the ground at the golf course (how would you score that btw)... I think you get the point.

This afternoon my son wanted to go over and play at my wife's parents house (who live directly behind us), so he and my wife took the long trek across the alley to go play. Just after they left, it started "coming up a flood" as they say here in Texas (which loosley translates to a "torrential downpour"). After a while I went over with an umbrella so they could come home with out getting soaked. While we were over talking w/ my father in law, it thundered (and lightininged how ever you'd say that, at the same time) the loudest I've ever heard it. We laughed and said how close that one was because there was no pause between the flash and the boom.

As we walked across the alley back to our house, we smelled wood burning (this seemed odd for such a hot afternoon). Looking down the alleyway we could actually see smoke low to the ground like fog in the early morning. My wife took our son back in our house as I ran down our street to see if I could see what was burning. As I walked down the street, the smoke grew thicker and thicker. Some of my neighbors were out, and we all started running towards the smoke (joking about how much help we would all be: wearing our rain soaked "flip-flops").

That lightning we'd heard had actually struck our neighbors house! There was dark smoke billowing out of their attic vent, and a few people were standing out in front of the house across the street from the one burning. The fire department was just pulling up, and you could see fire starting to peek out of the roof of their house. It didn't seem like much at first. The firemen quickly (though it seemed like forever) got hoses hooked up and went into the house. All of the sudden the vent where we first started seeing smoke pouring out, erupted into a big ball of flames. The fireball was literally inches from the neighbor's house.

Minutes later what was a tiny hole in the roof of the house had turned into a big black void where the roof of the attic used to be. The entire roof had flames shooting up 15 to 20 feet from the top of what used to be the crest of the house. The whole scene was surreal.

As I watched--in horror--my neighbors house burn, I couldn't help but think that this could very well be my house disintegrating before my eyes. We do, after all, have the tallest house on the block. At one point the ceiling in the master bedroom fell through, and you could see the fire burning uncontrolled through the bedroom window like the glass of a fireplace shielding the raging fire that you typically build to keep warm in the dead of winter. I felt so sad for these people though I didn't know them from Adam. I can't imagine what it must have felt like to so helplessly watch everything in your life go up in flames. They had escaped from their home with their lives... and nothing else. That's a pretty harsh reality to come to terms with. I still find it very difficult to go to sleep thinking about it. Everything smells of smoke (the damp night air has a lot to do with it I'm sure), and serves as a constant reminder of just how fortunate we were today. Fifteen minutes was all it took for that house to completely burn to the ground.

It was the longest fifteen minutes of my life.

God help us all.

A Command Line style string parser (in C#)

Tue, 08 Aug 2006 17:02:40 EDT

Last week I was writing a service that could be run as a console app. I needed to be able to parse a single string into an array like the shell does for command line apps, and the service does for start parameters. I did a little googling, but found only command line arg classes that put command line args into associative array's for easy indexing, which isn't what I was looking for.

The class had basically 2 requirements:

It had to be able to split the string on spaces (simple right?)
It had to escape spaces that were quoted (as well as quotes that were escaped).

First I tried to iterate through the string a character at a time, looking for spaces keeping the state of whether we were inside a quote or not, whether the current character was an escaped quote, and so on.

That was a major pain, so I stepped back and rethought my algorithm. this is what I ended up with, which was much simplier, and did exactly what I wanted without a lot of fuss.

So here's my command line parser:

public class CommandLineParser {
    CommandLineParser() { }
    public static string[] Parse(string str) {        
        if(str == null || !(str.Length > 0)) return new string[0];
        int idx = str.Trim().IndexOf(" "); 
        if(idx == -1) return new string[] { str };
        int count = str.Length;
        ArrayList list = new ArrayList(); 
        while(count > 0) {
            if(str[0] == '"') {
                int temp = str.IndexOf("\"", 1, str.Length - 1);
                while(str[temp - 1] == '\\') {
                    temp = str.IndexOf("\"", temp + 1, str.Length - temp - 1);
                }
                idx = temp+1;
            }
            if(str[0] == '\'') {   
                int temp = str.IndexOf("\'", 1, str.Length - 1);
                while(str[temp - 1] == '\\') {
                    temp = str.IndexOf("\'", temp + 1, str.Length - temp - 1);
                }
                idx = temp+1;
            }
            string s = str.Substring(0, idx);
            int left = count - idx;
            str = str.Substring(idx, left).Trim();
            list.Add(s.Trim('"'));
            count = str.Length;
            idx = str.IndexOf(" ");
            if(idx == -1) {
                string add = str.Trim('"', ' ');
                if(add.Length > 0) {
                    list.Add(add);
                }
                break;
            }
        }
        return (string[])list.ToArray(typeof(string));
    }
}