Sanity Free Coding

A CRC8 implementation in C#

Thu, 04 Feb 2010 22:20:18 EST

So I've tackled CRC32, CRC16, CRC16-CCITT implementations, and found myself wanting a CRC8 class to create checksums for small data (1-2 bytes) sets. Not having ever used or seen CRC8 in use before, I did some reading, and as far as I can tell, I've implemented it correctly... It works anyway, so without further ado, here's my implementation:

public static class Crc8 {
    static byte[] table = new byte[256];
    // x⁸ + x⁷ + x⁶ + x⁴ + x² + 1
    const byte poly = 0xd5;

    public static byte ComputeChecksum(params byte[] bytes ) {
        byte crc = 0;
        if ( bytes != null && bytes.Length > 0 ) {
            foreach ( byte b in bytes ) {
                crc = table[crc ^ b];
            }
        }
        return crc;
    } 

    static Crc8( ) {
        for ( int i = 0; i < 256; ++i ) {
            int temp = i;
            for ( int j = 0; j < 8; ++j ) {
                if ( ( temp & 0x80 ) != 0 ) {
                    temp = ( temp << 1 ) ^ poly;
                } else {
                    temp <<= 1;
                }
            }
            table[i] = (byte)temp;
        }
    }
}

This one differs slightly (API wise) from my previous ones, mainly because I was using it for checksum'ing smaller bits of data, so I made the ComputeChecksum method a params argument instead of a first class array type.

Here's a sample of how I was using it (and testing it):

byte crc = Crc8.ComputeChecksum( 1, 2, 3 );
byte check = Crc8.ComputeChecksum( 1, 2, 3, crc );
// here check should equal 0 to show that the checksum is accurate
if ( check != 0 ) {
    Console.WriteLine( "Error in the checksum" );
}

If you have any questions / comments / corrections, post them in the forums.

Pre-increment vs post-increment operators

Thu, 18 Dec 2008 04:47:08 EST

Ok, so here's a question for you that most people should have learned in school, but didn't. You have to answer this without running to visual studio.

What is the difference between ++i and i++?
What is the output of the following piece of code:

for(int i = 0; i < 5; ++i) {
    Console.WriteLine(i);
}

Is it: A)

or: B)

I'm sure there are quite a few who would choose A, but this is in fact incorrect (go ahead and run it in visual studio now).

Most of us when we learned C style programming were taught that pre-increment increments the value before taking the value, and that post increment takes the value then increments. After being taught that, pretty much every professor, every code sample, and everybody under the sun used post increment for every single iterative example in existence.

Question is... WHY?

Inside a loop, I cannot see why anyone would use post increment. What is the order of operation? Declare, loop body, compare, increment, loop body, compare, increment, ....

Unlike C++ (where there are there are actually 2 distinct operators: a pre and a post increment operator) C#, has only one generic "increment" / "decrement" operator, so exactly how the operator works is left completely out of our hands (and is handled internally by the framework). As stated in the ECMA spec (page 176 of the 4^th edition of the ECMA-334):

The run-time processing of a postfix increment or decrement operation of the form x++ or x-- consists of the following steps:

If x is classified as a variable:

x is evaluated to produce the variable.

The value of x is saved.

The saved value of x is converted to the operand type of the selected operator and the operator is invoked with this value as its argument.

The value returned by the operator is converted to the type of x and stored in the location given by the evaluation of x.

The saved value of x becomes the result of the operation.

By comparison, here is what is stated for a pre-increment operation (page 196 of ECMA-334 4^th edition):

The run-time processing of a prefix increment or decrement operation of the form ++x or --x consists of the following steps:

If x is classified as a variable:

x is evaluated to produce the variable.

The value of x is converted to the operand type of the selected operator and the operator is invoked with this value as its argument.

The value returned by the operator is converted to the type of x. The resulting value is stored in the location given by the evaluation of x and becomes the result of the operation.

So in the case of post increment, a copy has to be made, the op_Increment is invoked using the copy, the value is returned, and the copy overwrites the original value.

With pre increment, the value is passed into the op_Increment method, and its value is returned.

In the case of a loop, we are not using the value returned pre-increment, and are therefore only using the increment operation to alter the original value, so using post increment is completely pointless. Why anyone uses it is beyond me. Maybe its a case of not actually understanding whats going on.

There are a few places where it actually makes sense to use a post increment operation, but even these probably have better solutions to them as well:

int i = 0;
int j = i++;
// or
int[] table = { 0, 1, 2, 3, 4, 5, 6 };
int i = 0;
int j = table[i++];
int k = table[i++];
int l = table[i++];

So the moral of the story is... post increment wisely (have a good reason to use it, otherwise pre-increment).

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]
    ...
}

Having a named mutex allows us to stack synchronization across multiple 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 custom message to every window (the custom message was registered with RegisterWindowMessage by my running application, which means only my application knows what it is) 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;
    }
}

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(null == temp) 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( null == temp) 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) { 
        if(object.ReferenceEquals(a, null)) return false;      
        return a.Equals(b);
    }

    public static bool operator != (FakeEnum a, FakeEnum b) { 
        if(object.ReferenceEquals(a, null)) return true;
        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).

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

.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 BitConverter.GetBytes(crc);
    }

    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, and CRC8

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 BitConverter.GetBytes(crc);
    }

    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, and CRC8

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.

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));
    }
}

An IPAddress Control (the Win32 SysIPAddress32 control in C#)

Mon, 31 Jul 2006 01:16:43 EDT

The Common Controls library from the Platform SDK provides a control that Microsoft failed to provide a .NET counterpart to: the IPAddress Control (known as SysIPAddress32).

Quite a while ago I wrote a C# / .NET control that wrapped the functionality of the SysIPAddress32 control from comctl32.dll

I had a much better implementation back then (with quite a few nice things included), but the hard drive that it lived on has since died, and I just haven't wanted to spend the time putting all that stuff back into the control.

Some time after having written the "nice" version of this control, I posted the following code to another website. Now, it's all I have left of the original. There is a known problem with the handle to the font being disposed incorrectly, but the code that fixed that, was given to me by jfo from Microsoft, and I did a cut/paste of the solution without really paying much attention to it (kind of regretting that now...). You may notice that all "system" fonts will always be displayed in BOLD in the forms designer (even when the font is set to something else). THIS GOES AWAY AT RUNTIME, so don't worry! It's only a problem in the designer.

Anyway, here it is, my IPAddress Control:

/******************************************************/
/*          NULLFX FREE SOFTWARE LICENSE              */
/******************************************************/
/*  IPAddressControl                                  */
/*  by: Steve Whitley                                 */
/*  © 2004 NullFX Software                            */
/*                                                    */
/* NULLFX SOFTWARE DISCLAIMS ALL WARRANTIES,          */
/* RESPONSIBILITIES, AND LIABILITIES ASSOCIATED WITH  */
/* USE OF THIS CODE IN ANY WAY, SHAPE, OR FORM        */
/* REGARDLESS HOW IMPLICIT, EXPLICIT, OR OBSCURE IT   */
/* IS. IF THERE IS ANYTHING QUESTIONABLE WITH REGARDS */
/* TO THIS SOFTWARE BREAKING AND YOU GAIN A LOSS OF   */
/* ANY NATURE, WE ARE NOT THE RESPONSIBLE PARTY. USE  */
/* OF THIS SOFTWARE CREATES ACCEPTANCE OF THESE TERMS */
/*                                                    */
/* USE OF THIS CODE MUST RETAIN ALL COPYRIGHT NOTICES */
/* AND LICENSES (MEANING THIS TEXT).                  */
/*                                                    */
/******************************************************/


namespace NullFX.Controls {
    using System;
    using System.Net;
    using System.Windows.Forms;
    using System.Runtime.InteropServices;
    using System.Diagnostics;
    using System.Drawing;
    [StructLayout(LayoutKind.Sequential)]
    public struct Nmhdr {
        public IntPtr HWndFrom;
        public UIntPtr IdFrom;
        public int Code;
    }
    [StructLayout(LayoutKind.Sequential)]
    public struct NmIPAddress {
        public Nmhdr Hdr;
        public int Field;
        public int Value;
    }
    [StructLayout(LayoutKind.Sequential)]
    public struct InitCommonControlsEX {
        public int Size;
        public int Icc;
    }
    public enum IPField { OctetOne = 0, OctetTwo = 1, OctetThree = 2, OctetFour = 3 }
    public delegate void FieldChangedHandler(object sender, FieldChangedEventArgs e);
    public class FieldChangedEventArgs : EventArgs {
        private int _field, _value;
        public int Field {
            get { return _field; }
        }
        public int Value {
            get { return _value; }
        }
        public FieldChangedEventArgs(int field, int value)
            : base() {
            _field = field;
            _value = value;
        }
    }
    public class IPAddressControl : TextBox {
        private const int WM_NOTIFY = 0x004E,
            WM_USER = 0x0400,
            WM_REFLECT = WM_USER + 0x1C00,
            IPN_FIRST = -860,
            IPM_SETRANGE = (WM_USER + 103),
            IPM_GETADDRESS = (WM_USER + 102),
            IPM_SETADDRESS = (WM_USER + 101),
            IPM_CLEARADDRESS = (WM_USER + 100),
            IPM_ISBLANK = (WM_USER + 105),
            ICC_INTERNET_CLASSES = 0x00000800,
            CS_VREDRAW = 0x0001,
            CS_HREDRAW = 0x0002,
            CS_DBLCLKS = 0x0008,
            CS_GLOBALCLASS = 0x4000,
            WS_CHILD = 0x40000000,
            WS_VISIBLE = 0x10000000,
            WS_TABSTOP = 0x00010000,
            WS_EX_RIGHT = 0x00001000,
            WS_EX_LEFT = 0x00000000,
            WS_EX_RTLREADING = 0x00002000,
            WS_EX_LTRREADING = 0x00000000,
            WS_EX_LEFTSCROLLBAR = 0x00004000,
            WS_EX_RIGHTSCROLLBAR = 0x00000000,
            WS_EX_NOPARENTNOTIFY = 0x00000004,
            WS_EX_CLIENTEDGE = 0x00000200;
        private int[] values = new int[4];
        bool initialized = false;		
        public event FieldChangedHandler FieldChanged;
        public IPAddressControl()
            : base() {
            for(int i = 0; i < 4; i++)
                values[i] = 0;
        }
        [DllImport("comctl32")]
        static extern bool InitCommonControlsEx(ref InitCommonControlsEX lpInitCtrls);

        protected virtual void OnFieldChanged(FieldChangedEventArgs e) {
            if(FieldChanged != null) FieldChanged(this, e);
        }
        protected override CreateParams CreateParams {
            get {
                if(!initialized) {
                    InitCommonControlsEX ic = new InitCommonControlsEX();
                    ic.Size = Marshal.SizeOf(typeof(InitCommonControlsEX));
                    ic.Icc = ICC_INTERNET_CLASSES;
                    initialized = InitCommonControlsEx(ref ic);
                }
                if(initialized) {
                    CreateParams cp = base.CreateParams;
                    cp.ClassName = "SysIPAddress32";
                    cp.Height = 23;
                    cp.ClassStyle = CS_VREDRAW | CS_HREDRAW | CS_DBLCLKS | CS_GLOBALCLASS;
                    cp.Style = WS_CHILD | WS_VISIBLE | WS_TABSTOP | 0x80;
                    cp.ExStyle = WS_EX_NOPARENTNOTIFY | WS_EX_CLIENTEDGE;
                    if(RightToLeft == RightToLeft.No 
                                                    || (RightToLeft == RightToLeft.Inherit 
                                                    && Parent.RightToLeft == RightToLeft.No)) {
                        cp.ExStyle |= WS_EX_LEFT | WS_EX_LTRREADING | WS_EX_RIGHTSCROLLBAR;
                    } else {
                        cp.ExStyle |= WS_EX_RIGHT | WS_EX_RTLREADING | WS_EX_LEFTSCROLLBAR;
                    }
                    return cp;
                } else {
                    return base.CreateParams;
                }
            }
        }
        public bool SetIPRange(IPField field, byte lowValue, byte highValue) {
            if(!initialized) return false;		
            Message m = Message.Create(Handle, IPM_SETRANGE, (IntPtr)((int)field), MakeRange(lowValue, highValue));
            WndProc(ref m);
            return m.Result.ToInt32() > 0;
        }
        public System.Net.IPAddress IPAddress {
            get {
                if(!initialized) return IPAddress.None;			
                return IPAddress.Parse(base.Text);
            }
        }
        public bool IsBlank {
            get {
                if(!initialized) return !(base.Text.Length > 0);
                Message m = Message.Create(Handle, IPM_ISBLANK, IntPtr.Zero, IntPtr.Zero);
                WndProc(ref m);
                return m.Result.ToInt32() > 0;
            }
        }
        new public void Clear() {
            if(!initialized) {
                base.Clear();
                return;
            }		
            Message m = Message.Create(Handle, IPM_CLEARADDRESS, IntPtr.Zero, IntPtr.Zero);
            WndProc(ref m);
        }
        private System.Net.IPAddress GetIpAddress(IntPtr ip) {
            if(!initialized) return IPAddress.None;		
            return new IPAddress(ip.ToInt64());
        }
        private IntPtr MakeRange(byte low, byte high) {
            return (IntPtr)((int)((high << 8) + low));
        }
        protected override void WndProc(ref Message m) {
            if(m.Msg == (WM_REFLECT + WM_NOTIFY)) {
                NmIPAddress ipInfo = (NmIPAddress)Marshal.PtrToStructure(m.LParam, typeof(NmIPAddress));
                if(ipInfo.Hdr.Code == IPN_FIRST) {
                    if(values[ipInfo.Field] != ipInfo.Value) {
                        values[ipInfo.Field] = ipInfo.Value;
                        OnFieldChanged(new FieldChangedEventArgs(ipInfo.Field, ipInfo.Value));
                    }
                }
            }
            base.WndProc(ref m);
        }
    }
}

It does have one wrapped event from the original control and that is FieldChanged, which provides feedback when each octet is changed (similar to TextChanged for a text box, but only fires after the user has entered the entire text for that octet). Likewise, if the value of that octet is larger than a byte, it is automatically changed back to 255 (or the max value of a byte). When the event fires, it passes back, the Octet that was changed, and its value.

You can specify the IP Range (which the original control allows, and I've wrapped into this control as well) so that you can edit the control to only accept a specified IP Address Range.

I've also provided Native Clear functionality as well as the IsBlank from the original control. I added a System.Net.IPAddress property so that when accessing the IPAddress of the control, you didn't need to parse the System.Net.IPAddress every time. My original control completely removed the "Text" property so that you got and set the IPAddress through this property, but alas, that functionality doesn't exist in this control.

UPDATE: 8/25/2006 - Made 2 changes to the source code. 1. added some Initialization logic to keep InitCommonCtrls from being called multiple times and, 2. added styles for ClassStyle, StyleEX and Style to keep an exception from being thrown in certain cases when a WM_GETTEXTLENGTH message was sent.

For questions, comments, bugs, or anything else in this control, feel free to use the Windows Controls section of the forum here.

The C# 3.0 language specification

Sat, 29 Jul 2006 01:50:13 EDT

I know I'm a bit late here, but better late than never.

I've been reading over some of the changes to C# for version 3. I had heard that v3 would be v2 with the addition of the new WPF, but looking over the new spec (well, fairly new anyway), there is quite a bit more.

Implicit types, method extensions, lambda expressions, object / collection initializers, and LINQ... C# is going to look really weird! So much for simplicity.

Implicit types (csharp meets vb or php) allow you to define the variable without a (or with an implied) type:

var foo = "hello";
var bar = 32;

so foo is implied to be of type string, and bar is implied to be of some numeric type.

Method extensions look very strange. Think of old dog learns new tricks meets operator overloading. Method extensions allow you to create "extension" methods for existing types:

public class Bar {
    string what = "hello";
    public string What { get { return what; } set { what = value; } }
    public Bar() {}
    public void Hello() { 
        Console.WriteLine(what); 
    }
}

public static class Foo {
    public static void SayHelloToSteve(this Bar bar) {
        bar.What += " steve";
        bar.Hello();
    }
    public static void SayHelloToSomeone(this Bar bar, string who) {
        bar.What = who;
        bar.Hello();
    } 
}

public class Program {
    static void Main(string[] args) {
        Bar b = new Bar();
        b.Hello();
        b.SayHelloToSteve();
        b.SayHelloToSomeone("Hello Bob!");
    }
}

Notice that SayHelloToSteve() and SayHelloToSomeone(string s) are not member methods of the Bar class, but are invoked as if they were (by virtue of the Method extension defined in Foo that are available to Bar). This seems like a feature that will be abused to defeat inheritance (by adding reflection to the method extenstions to manipulate internal class memebers without inheriting and changing functionality of the object) that would otherwise look odd and ugly.

OUTPUT:

hello
hello steve
Hello Bob!

At this point lambda expressions dont make much sense to me, but it seems its a way to define more than one method body in an anonymous method.

Object / collection initialization makes initialization a lot easier. I don't know if you've ever wanted to declare a new object inline inside a method, only to realize that you needed to set a few properties before it was used, well this is the answer to that:

myObject.Blah(new SomeObject() { PropertyA = 1, PropertyB = "dude", PropertyC = false });

Then there's LINQ: which feels something like SQL for C#.

feel free to download the spec here

fin

PHP Webservices and C# / .NET SOAP Clients

Mon, 03 Jul 2006 02:17:59 EDT

Code Zulu Bind Maker is a project I started working on about 3 years ago. Its a stupid little app that configures game settings for Counter-Strike. When I wrote it, version 1.6 was in beta, and everybody played version 1.5 (which was ever so different). Anyway I run a website that supports the app, and of course, its written in PHP / MySql (my poison of choice on the web).

The reason for the boring and seemingly pointless background is that ever since I wrote the app, I always wanted to integrate the website and application, but never really thought of a "good" way to do it. A couple days ago, I had some spare time and sat down to see how easy it would be to create some PHP webservices that I could easily consume in C#. I had been considering expanding the community aspect of the bind maker website into the application so that they'd work seamlessly together. I also wanted to add a common place that gaming communities could spend their time (which I had previously planned for just the website, but was thinking of the possibilities of bringing that into the app as well), and a PHP webservice combined with a C# windows app seemed like the best option.

C# webservices (server side) are about as easy-as-it-gets to write. C#'s SOAP client is completely transparent (or I should say completely generated so you code just like you would use any other objects) and is completely brainless to use. Since I'd never done webservice work in PHP, I started asking Mr. Google how it worked, and what would you now but that I stumbled across the NuSOAP library for php. It sure beat the heck out of writing all my WSDL files by hand, wrapping and unwrapping stupidly simple SOAP messages, and hacking everything very poorly.

My first PHP webservice iteration was a simple "hello <name> " web method. It used a simple type (xsd:string) as its parameter and returned a simple type (again another xsd:string) as its return value and looked like this:

 /**
 * ProcessSimpleType method
 * @param string $who name of the person we'll say hello to
 * @return string $helloText the hello  string
 */
function ProcessSimpleType($who) {
	return "Hello $who";
}

NuSoap was great. It took care of all the nitty-gritty work that I had previously done myself. All it took was about 8 lines of code to set up the SOAP server and register the method and my types.

require_once("lib/nusoap/nusoap.php");
$namespace = "http://sanity-free.org/services";
// create a new soap server
$server = new soap_server();
// configure our WSDL
$server->configureWSDL("SimpleService");
// set our namespace
$server->wsdl->schemaTargetNamespace = $namespace;
// register our WebMethod
$server->register(
                // method name:
                'ProcessSimpleType', 		 
                // parameter list:
                array('name'=>'xsd:string'), 
                // return value(s):
                array('return'=>'xsd:string'),
                // namespace:
                $namespace,
                // soapaction: (use default)
                false,
                // style: rpc or document
                'rpc',
                // use: encoded or literal
                'encoded',
                // description: documentation for the method
                'A simple Hello World web method');
                
// Get our posted data if the service is being consumed
// otherwise leave this data blank.                
$POST_DATA = isset($GLOBALS['HTTP_RAW_POST_DATA']) 
                ? $GLOBALS['HTTP_RAW_POST_DATA'] : '';

// pass our posted data (or nothing) to the soap service                    
$server->service($POST_DATA);                
exit();

That was it. From visual studio I was then able to consume the webservice by adding a web reference

This article was first written with visual studio 2005. Visual studio 2008 and 2010 no longer have the "Add Web Reference" menu item. Instead they have an option to add a service reference. Selecting this option ends up generating a WCF C# client proxy, but we'll want to use the asmx style web service client proxy, so we'll navigate to the add web reference dialog which is hidden deep inside Add Service Reference dialog.

Visual Studio 2008 and 2010 Only
Right click on the references folder, and select Add Service Reference

Click on the advanced button

Finally click the Add Web Reference button

With the reference added, I put a button on my form, and added the following button click event handler:

private void button1_Click(object sender, EventArgs e) {
    SimpleService svc = new SimpleService();
    string s = svc.ProcessSimpleType("steve");
    MessageBox.Show(s);
}

Ran my application, pressed the button (which in turn called the webservice), and voilà I get a message box telling me Hello:

That's great! Completely useless, but great!

Now to get a little more complicated... I had planned on using complex data types that would be consumed by both PHP and .NET clients (A PHP SOAP client for the website, and .NET client for the windows application). It may sound stupid to have a PHP client when most likely I'd have access to the method directly, but the server that is going to host the webservices is actually different than the "web presence" server I host my website on. Anyway, the test complex types I came up needed to look like simple structs (in C#) which would also be used in an array, and they looked something like this:

public struct MySoapObject {
    public string Author;
    public string Name;
    public string Description;
    public string Text;
    public int VoteTotal;
    public int VoteCount;
}

MySoapObject[] soapObjects = new MySoapObject[10];

so I added the definitions in PHP using NuSOAP like this:

$server->wsdl->addComplexType(
    'MySoapObject',
    'complexType',
    'struct',
    'all',
    '',
    array(
        'Author' => array('name'=>'Author','type'=>'xsd:string'),
        'Name' => array('name'=>'Name','type'=>'xsd:string'),
        'Description' => array('name'=>'Description','type'=>'xsd:string'),
        'Text' => array('name'=>'Text','type'=>'xsd:string'),
        'VoteTotal' => array('name'=>'VoteTotal','type'=>'xsd:int'),
        'VoteCount' => array('name'=>'VoteCount','type'=>'xsd:int')
    )
);

$server->wsdl->addComplexType(
    'MySoapObjectArray',
    'complexType',
    'array',
    '',
    'SOAP-ENC:Array',
    array(),
    array(array('ref'=>'SOAP-ENC:arrayType','wsdl:arrayType'=>'tns:MySoapObject[]')),
    'tns:MySoapObject'
);

I defined the method in PHP that would take in an array of MySoapObjects, process them, and then return one MySoapObject that it had "processed".

That method looked like this:

function ProcessMySoapObject($mySoapObjects) {
	$mso = $mySoapObjects[3];
	$mso['Name'] = "|||";
	return $mso;
}

The SOAP server registration:

$server->register(
    'ProcessMySoapObject',
    array('soapObjects'=>'tns:MySoapObjectArray'),
    array('return'=>'tns:MySoapObject'),
    $ns,
    false,
    'rpc',
    false,
    'Processes an array of MySoapObjects and returns one of them');

And I did exactly the same as I did before--and added the web reference in visual studio to my project. This time not only did Visual Studio add the Service class and web method, it added the 2 data types I had defined in PHP on my SOAP server (actually, it just built the MySoapObject, and the array was left out because arrays are an implied data type).

I changed my button click event in my windows form and added the following code:

private void button1_Click(object sender, EventArgs e) {
    Services s = new Services();
    MySoapObject[] ms = new MySoapObject[10];
    for(int i = 0; i < ms.Length; i++) {
        ms[i] = new MySoapObject();
        ms[i].Author = "Steve";
        ms[i].Description = "The One that should be returned";
        ms[i].Name = i.ToString();
        ms[i].Text = "something something something " + i.ToString();
        ms[i].VoteCount = i * 2;
        ms[i].VoteTotal = (int)Math.Pow(ms[i].VoteCount, 2);
    }
    MySoapObject retn = s.ProcessMySoapObject(ms);
    string output = "";
    output += retn.Author + "\t\t\r\n";
    output += retn.Description + "\t\t\r\n";
    output += retn.Name + "\t\t\r\n";
    output += retn.Text + "\t\t\r\n";
    output += retn.VoteCount.ToString() + "\t\t\r\n";
    output += retn.VoteTotal.ToString() + "\t\t\r\n";
    MessageBox.Show(output);
}

Compiled, ran and clicked.

Simple, Easy, Can't believe I never tried it before now!

This opened up a whole new world of opportunities in cross-platform distributed computing that I'd never exposed myself to before... what a wonderful thing!

Dependency Scanner (for .NET 1.1)

Thu, 23 Mar 2006 03:12:29 EST

Download Project & Source Code

Here's a little tool I wrote a while ago. Right now its only for .NET 1.1, but I'm working on a port for 2.0 (which should look a lot nicer).

When I wrote this, I was dealing with assemblies that had very complex inner-dependencies. Some assemblies were private, others were shared, and I ended up having to have a ton of ildasm.exe's open to the assembly manafest to try to see which assembly had referenced which assembly and had to verify that the assembly version referenced was correct. On top of that I needed to verify that assemblies that were referenced--that had policy files--were being redirected to the correct versions.

Basically all this tool does, is load an assembly, display its version, and lists any referenced assemblies, their versions, and whether or not the reference version resolves to any other version. It doesn't look like much, but its saved me a lot of time and head ache. It also has a copy / paste feature that can copy selected listview data to the clipboard in a nice column formatted manner.

Here's the main bulk of whats going on. Basically what I did, was to load the assembly file, then try to load another assembly based on the partial name from the assembly file that I just loaded. At first glance, it looks as if I'm creating 2 identical assembly objects. The difference is, that if one assembly was version 1.1.2 and there was a policy file for version 1.1.2 to redirect to version 1.2.3, the second assembly load would load version 1.2.3 instead of version 1.1.2. That info would be displayed in the top line of the assembly entry

private void ResolveAssemblyImports(string file) {
    try {
        Assembly asm = Assembly.LoadFile(file);
        Assembly d = Assembly.LoadWithPartialName(asm.FullName);

Then I matched the two assemblies version numbers to see if they matched

        string ver = "", re = "";
        bool nill = d == null;
        if(!nill) {
            re = _r.Match(d.FullName).Groups["version"].Value;
        } else {
            re = "NULL";
        }
        ver = _r.Match(asm.FullName).Groups["version"].Value;
        bool r_1 = false;
        if(ver != re && re != "NULL") {
            Version v_1 = new Version(ver);
            Version v_2 = new Version(re);
            if(v_2 >= v_1) r_1 = true;
        }
        AddItem(asm.GetName().Name, "----", ver, re, "True", nill ? "Failed" : (r_1 ? "True" : "False"));

Then I iterate through the assembly's referenced assemblies and try to do the same thing (match version numbers & see if they resolve to the same version)

        foreach(AssemblyName asmName in asm.GetReferencedAssemblies()) {
            string v1 = _r.Match(asmName.FullName).Groups["version"].Value,
                v2 = v1;
            bool exist = false, res = false;
            Assembly dep;
            try {
                dep = Assembly.LoadWithPartialName(asmName.FullName);
                if(dep != null) {
                    string temp = _r.Match(dep.FullName).Groups["version"].Value;
                    exist = true;
                    if(v2 != temp) {
                        Version v = new Version(v2);
                        Version t = new Version(temp);
                        if(t >= v) res = true;
                    }
                }
            } finally {
                AddItem("    +----", asmName.Name, v1, v2, exist.ToString(), res.ToString());
            }
        }
    } catch {
    }
}

Then I finally print out the results of my findings to the listview.

I had forgotten about this app until today when I couldn't understand why I kept getting an error for a method that had been updated in the assembly I was referencing. I pulled this tool out and saw that it indeed referenced the correct assembly but because another assembly being used referenced an older version of that assembly, the local copy was using the newer version but the older version was in the GAC so my code was using the older assembly that didnt have the current code that I needed (confused... I am and I was there).

Anyway, here's the project / source code for the app.

Update 7/16/2009 I've converted this app over to .NET 3.5 and complied app binaries that can be downloaded here

Visual Studio .NET 2005 Troubleshooting Tool

Fri, 02 Dec 2005 01:16:30 EST

I was having some troubles with the final release visual studio Team System. I've been using VS.NET 2005 on my home computer since the first previews were available on MSDN. I had installed and uninstalled each release of the IDE. I was experiencing problems viewing some of the docking window contents (entire panels loosing their contents, and were not able to be closed). I found A trouble shooting tool on Aaron Stebner's blog. I ran it, it found an orphaned beta assembly that was causing all the problems, and now I'm up and running without any problems...

Very Nice!

A Battlefield 2 Rank Avatar Script in PHP

Wed, 21 Sep 2005 01:29:34 EDT

This is a little departure from my typical topic.

To cut a rather tedious and boring story short, I play Battlefield 2, which has a cool stats service that folks have been hacking with outside of the game (the game has a stats board built in, which stats board uses some pseudo web-services to obtain game statistic info).

There are a multitude of server hosts out there that generate dynamic signature images with your game stats in them, so that you can look cool and show off how much time you actually waste online gaming, on every forum you frequent.

I decided to join the masses and write a script that pulls my users rank and score from the stats servers and returns an image that can be used as an avatar on most bulletin board systems out there. I had a size restriction on the server I wanted it for, so the images produced are 80x80 and less than 6k in size.

Using the avatar script is pretty easy, you direct the image source url to the server where you install the script (or you can just use the one here)

html
<img src="http://www.sanity-free.org/bf2rank/?pid=45647367">

bbCode
[img]http://www.sanity-free.org/bf2rank/?nick=[OinK]_MadHatter[/img]

most bulliten board systems have places for you to link in a remote avatar, and one would add this same url w/ a name just as you would a normal image.

One annoying thing about most bbcode systems is that they require a valid image extension (.png, .jpg, .gif ... ) on the url inside the [img][/img] blocks (otherwise it just shows text inside the img blocks). To get your rank image to show up if you're having troubles is to simply add an &avatar.jpg to the end of the url. The php code will ignore it, and the forum will think its a valid image and will show it correctly. Another way is to use the simple url described in the forums here.

The resulting image looks like this:

You can also specify a couple of options.

adding &score will display your global score at the top of the image.
ex:
adding &no_text to the end of the url will keep the text from being written on the image.
ex:
adding &delta to the end will show the difference in your progress between your last rank and your next one.
ex:
you can also combine any combination of them as well (this one is using &delta, &no_text, and &score options).
ex:

EDIT Feb. 15 2006: since the last patch, I havent updated this article source code. HERE'S the most recent version of the script. you can download the package and copy that over the script provided.

EDIT March 20 2006: I updated the code to include nick name resolution (using searchforplayers.aspx). the link to the code above has that change in it. so you can use your player nick again instead of trying to find out your player ID.

EDIT June 30 2006: I removed the source code from the article and repacked the download with everything you need.

EDIT July 18 2006: I've added "easy url's" for the rank avatars. for more info on that--and if you'd like to add them to your server--take a look at the thread in the forums here.

Here's the code for the script (the download has a true type font that needs to be located in the script dir w/ all the image files which are also referenced, so make sure to download the script pack):

Download source and resources here.

Stupid .NET 1.1 Service Pack 1

Tue, 06 Sep 2005 19:24:32 EDT

Service pack 1 strikes again.

    using System;
    using System.Drawing;
    using System.IO;
    using System.Reflection;
    public class Resources {
        private Resources() {}
        public static Image LoadImageFromResource(string path) {
            Image i = null;
            using ( Stream s = 
                      Assembly.GetExecutingAssembly().GetManifestResourceStream(path) ) {
                if(s != null) i = Image.FromStream(s, true, true);
            }
            return i;
        }
    }

This is part of a general use utility that I frequently use. An odd bug that came out of this is that the overloaded method

Image.FromStream(Stream, Boolean, Boolean)

was added in Service Pack 1 for .net v1.1 BUT NEVER DOCUMENTED!!!. Well, ok, that's not entirely true, It is documented... in v2.0 documentation... So if you wrote this in 1.1sp1 and deploy it to a machine with out sp1 you'll get a method not found exception when trying to load the image from stream using the above overload--non sp1 only has FromStream(Stream, Boolean)

Nothing like being incompatible with the same version of the framework eh?