In the past several years, on several projects, I’ve seen many lines of code at the beginning of public interface methods that look like:

    public class WebServer
    {
        public void BootstrapServer(int port, string rootDirectory, string serverName)
        {
            if( rootDirectory == null )
            {
                throw new ArgumentNullException( "rootDirectory" );
            }
            if( serverName == null )
            {
                throw new ArgumentNullException( "serverName" );
            }

            // Bootstrap the server
        }
    }

I realize the need, since we don’t have real DbC in .NET (yet), but I REALLY dislike this and feel it to be a pretty bad smell.  It feels unDRY, obscures essence, and I just plain don’t like it.

So, here is an implementation that makes it tolerable, if not enjoyable (because of the coolness of using static reflection), because I think it actually adds to the essence and overall readability of a given method.

This is what the above code can now look like:

    public class WebServer
    {
        public void BootstrapServer( int port, string rootDirectory, string serverName )
        {
            Guard.IsNotNull( () => rootDirectory );
            Guard.IsNotNull( () => serverName );

            // Bootstrap the server
        }
    }

And here is the implementation:

    public static class Guard
    {
        public static void IsNotNull<T>(Expression<Func<T>> expr)
        {
            // expression value != default of T
            if (!expr.Compile()().Equals(default(T)))
                return;

            var param = (MemberExpression) expr.Body;
            throw new ArgumentNullException(param.Member.Name);
        }
    }

Lovin it!  Hope you do too.

Now, I’ve never been a fan of INotifyPropertyChanged myself, mostly because it feels wet (read: not DRY).  I’m working on a WPF app at the moment, and have come to realize, if I embrace INotifyPropertyChanged, I get to take full advantage of the excellent WPF databinding story.

Here is what a normal use of INotifyPropertyChanged looks like:

    public class Person : INotifyPropertyChanged
    {
        private string _firstName;
        private string _lastName;

        public event PropertyChangedEventHandler PropertyChanged;

        public string FirstName
        {
            get { return _firstName; }
            set
            {
                if (_firstName != value)
                {
                    _firstName = value;
                    FirePropertyChanged("FirstName");
                }
            }
        }

        public string LastName
        {
            get { return _lastName; }
            set
            {
                if (_lastName != value)
                {
                    _lastName = value;
                    FirePropertyChanged("LastName");
                }
            }
        }

        private void FirePropertyChanged(string propertyName)
        {
            if (PropertyChanged != null)
            {
                PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
            }
        }
    }

Here is what the static reflection use of INotifyPropertyChanged looks like:

    public class PersonStaticReflection : NotifyPropertyChanged
    {
        private string _firstName;
        private string _lastName;

        public string FirstName
        {
            get { return _firstName; }
            set { SetProperty(()=> FirstName, ()=> _firstName, value); }
        }

        public string LastName
        {
            get { return _lastName; }
            set
            {
                SetProperty( () => LastName, () => _lastName, value, () =>
                   {
                       // do something useful here
                   });
            }
        }
    }

Doesn’t that just feel DRYer?  It does to me!

There are several important pieces to note:

• Inheriting from NotifyPropertyChanged, this is the class that holds the SetProperty method, and hides the static reflection magic.
• We’re calling SetProperty with three arguments in the FirstName property
  • first: a LINQ Expression pointing to the property we’re changing
  • second: a LINQ Expression pointing to the field to backing the property
  • third: the new, incoming value
• We’re calling SetProperty with a fourth argument in the LastName property
  • fourth: an action that will get executed only if the values were different

The SetProperty method, is going to look at the current value of the field, and the incoming value.  If the two are different, it will assign the new value to the field, and then fire the NotifyPropertyChanged event, with the name of the property given via the first argument.  I ended up pulling this into its own class so I could use it as the layer supertype in my View Model layer. Here is the implementation:

    public class NotifyPropertyChanged : INotifyPropertyChanged
    {
        public event PropertyChangedEventHandler PropertyChanged;

        protected void SetProperty < T>( Expression < Func> propExpr, Expression> fieldExpr, T value )
        {
            SetProperty(propExpr, fieldExpr, value, ()=> { });
        }

        protected void SetProperty < T>( Expression < Func> propExpr, Expression < Func < T>> fieldExpr, T value, Action doIfChanged )
        {
            var prop = (PropertyInfo)((MemberExpression)propExpr.Body).Member;
            var field = (FieldInfo)((MemberExpression)fieldExpr.Body).Member;

            var currVal = prop.GetValue( this, null );

            if( currVal == null && value == null )
                return;
            if( currVal == null || !currVal.Equals( value ) )
            {
                field.SetValue( this, value );
                doIfChanged();

                if( PropertyChanged != null )
                    PropertyChanged( this, new PropertyChangedEventArgs( prop.Name ) );
            }
        }
    }

Questions/comments/likes/dislikes? Let me know.

I know, as soon as you read the title for this, your brain started making up excuses why you wouldn’t ever be able to contribute to a group in this way.  Believe me, been there, done that. Get. Over. It!  Here is a list of your excuses, and reasons why they’re not valid.  If you have any other excuses I missed, I’d be glad to tell you why its invalid as well

• Excuse #1: I don’t have a good story/content.
• FALSE: You almost certainly know something intimately that none of the rest of us know.  We are all thirsting for information, do us a favor and share it with us!
• Excuse #2:  I’m not an expert on anything.
• DOESN’T MATTER: What a coincidence!  None of the rest of us are either!  Just remember, “there are no smart guys, just us”… that includes you!  If you REALLY don’t know anything cool enough to talk about… go spend 10-20 hours learning something new/cool, distilling it down to 60 minutes so we can all leech off your brain.
• Excuse #3:  I’m scared/anxious/have issues talking in front of people/etc.
• GREAT!: What better way to practice than in a small intimate setting with a few of like minded peers?  This is a great opportunity to learn new things, and step out of your comfort zone to grow personally and professionally.
• Excuse #4:  I suck at PowerPoint.
• ALL THE BETTER:  I, personally, would rather see code than PowerPoint any day.
• Excuse #5:  I don’t know .NET very well.
• AWESOME:  We don’t necessarily care about .NET (our speaker last night is a non-.NET dude!).  Our main goal is continuous improvement, and the practices and principles that will make us better.

I’d like to invoke a few loosely translated Fight Club Rules on us.
  [Originals]
  Rule #1:  You don’t talk about fight club.
  Rule #2:  You don’t talk about fight club.
  …
  Rule #8  If this is your first night at Fight Club, you have to fight.
  [Translated]
  Rule #1:  You must talk about Indy Alt.NET
  Rule #2:  You must talk about Indy Alt.NET
  …
  Rule #8:  If you have not presented before at Indy Alt.NET, then you have to present (sometime, not necessarily this upcoming time, I won’t hold you to it like Mr. Durden would).

The topic is on team roles. We’re planning on having a

• BA - Sorry A-Team fans, this is a Business Analyst, not Mr. T
• Developers - All who serve at different levels in their own organizations
• PM - [Hopefully] If you’re a PM, and can come, please do, we need you!

The goal is really just to have good conversation about different roles in different organizations so we can all learn something by the way other organizations behave.

As usual, free pizza and networking starting at 5:15, with the talk starting at 6:00.

Logistics:
Tonight (October 16)
6:00P - 8:00P (food and networking at 5:15)
Ivy Tech near Fall Creek and Meridian on the north side of Fall Creek
Auditorium, 4th Floor 50 W Fall Creek Pkwy North Dr
Indianapolis, IN 46208
Map

Hope to see you there!

The list is not all about technical stuff.  It is really stemmed from some things God has laid in front of me lately.

Becoming a message

Our pastor shared a great quote with our church last weekend that really stood out to me.

…my life is my message  - Gandhi

What would my message be if someone asked me today?
What would my message be if someone asked you today?
What would your message be if someone asked you today?

I’m guessing there will be more about this coming soon.

Continuous Improvement

This area is far more about you than it is about me.  Sure, I have much to learn, have a long list of areas of which I’d like to personally continue to improve.I feel a great need to help my colleagues, help my company, and help my community.  Something tells me I’m in a unique position to make an impact on each.So here is a list of areas I’d like to improve (in to particular order):

• Technical Breadth
• Technical Depth
• Leadership Skills
• Management Skills
• Physical Health
• Faith
• Creativity
• Being a better husband
• Brewing better coffee
• …

Back to Basics

I’m a firm believer in fundamentals.  I’d like to re-explore what the core fundamentals of the industry are, and find out where I need to brush up/start over/start (for the first time).

Okay… enough for now.  Stay tuned.

For those of you that read this, or find this, I’ve put together a PocketMod for the session schedule.  IMO, the UI is easier to use than the mini poster.  I’m sharing so you can have one too!

Here it is:  IndyTechFest PocketMod

Here is how I did it:

• Used Word to create this: PocketMod source
• Used the Office 2007 PDF Publisher to publish it to a PDF
• Used the PDFtoPocketmod converter app to convert the 8-page PDF to a 1-page PDF with all the pages squished and arranged just right
• Printed, and trimmed the margins with a paper cutter
• Folded and snipped, via the video at Pocketmod.

Super simple, super awesome.

Sometimes I find myself needing to map instances/values of one type to another.  For example, on my current project we have an enumeration in our communications layer, and a VERY similar one in the domain layer.  The reason for this is so we don’t have to be referencing the communications layer version all over in the domain code.  So, there is naturally a one to one mapping between these enumerations.

Consider the following enumerations:

enum Polygons
{
    Triangle,
    Rectangle,
    Pentagon,
    Other
}

enum NumSides
{
    Three,
    Four,
    Five,
    More
}

This is the code I usually write to solve this problem:

private Polygons MapShapes( NumSides sides )
{
    switch( sides )
    {
        case NumSides.Three:
            return Polygons.Triangle;
        case NumSides.Four:
            return Polygons.Rectangle;
        case NumSides.Five:
            return Polygons.Pentagon;
        case NumSides.More:
            return Polygons.Other;
        default:
            throw new NotSupportedException(
                string.Format( "Mapping to Polygons from NumSides value {0}
                    is not supported", sides.ToString() ) );
    }
}

private NumSides MapShapes( Polygons polygon )
{
    switch( polygon )
    {
        case Polygons.Triangle:
            return NumSides.Three;
        case Polygons.Rectangle:
            return NumSides.Four;
        case Polygons.Pentagon:
            return NumSides.Five;
        case Polygons.Other:
            return NumSides.More;
        default:
            throw new NotSupportedException(
                string.Format( "Mapping to NumSides from Polygons value {0}
                    is not supported", polygon.ToString() ) );
    }
}

It turns out we had 3 said enumerations.  So picture the above, copied 3 times.  This thing was just begging for abstraction!

I came up with a Generic (proper) Map class that you can add mappings to and retrieve the corresponding mapped value of the other type… both directions.  Here is the implementation:

public class Map
{
    private Dictionary _oneToTwo;
    private Dictionary _twoToOne;

    public Map()
    {
        _oneToTwo = new Dictionary();
        _twoToOne = new Dictionary();
    }

    public Map Add( Type1 value1, Type2 value2 )
    {
        _oneToTwo.Add( value1, value2 );
        _twoToOne.Add( value2, value1 );
        return this;
    }

    public Type1 this[Type2 value]
    {
        get
        {
            if( !_twoToOne.ContainsKey( value ) )
            {
                throw new NotSupportedException(
                    string.Format( "Mapping from type {0} to type {1} with
                                    value {2} is not defined",
                        typeof( Type2 ).Name,
                        typeof( Type1 ).Name,
                        value.ToString() ) );
            }
            return _twoToOne[value];
        }
    }

    public Type2 this[Type1 value]
    {
        get
        {
            if( !_oneToTwo.ContainsKey( value ) )
            {
                throw new NotSupportedException(
                    string.Format( "Mapping from type {0} to type {1} with
                                    value {2} is not defined",
                        typeof( Type1 ).Name,
                        typeof( Type2 ).Name,
                        value.ToString() ) );
            }
            return _oneToTwo[value];
        }
    }
}

And, here it is in action:

Map<NumSides, Polygons> shapeMap = new Map<NumSides, Polygons>()
                                    .Add( NumSides.Three, Polygons.Triangle )
                                    .Add( NumSides.Four, Polygons.Rectangle )
                                    .Add( NumSides.Five, Polygons.Pentagon )
                                    .Add( NumSides.More, Polygons.Other );

// shape1 value is Polygons.Rectangle
Polygons shape1 = shapeMap[NumSides.Four]; 

// shape2 value is NumSides.Three
NumSides shape2 = shapeMap[Polygons.Triangle];

This not only works with enumerations, but any type.  I see an extension to this possibly allowing for a default mapping, and possibly constraining Type1 and Type2 to be IComparable or something like that as well, so you can have more control over your matching than whatever the default matching behavior that the Dictionary uses is.

That’s it… enjoy!

My requirements of “better” are:

• Case statements are automatically scoped
• I can switch on more than simple types
• I can have custom logic for my matching criteria

But why not just use if/else if/else…?

Good question, I’m glad you asked! However, I don’t have an excellent answer other than personal preference. if/else if/else is okay sometimes, but other times I have a deterministic set of conditions, and a switch type construct feels more symmetrical to me. I loves me some symmetric feeling code, it just feels cleaner somehow.

So I’ll present a somewhat contrived example just so you can see what the usage looks like, then we’ll see the code.

Usage

public void DoSomething()
{
	object foo = new object();
	object bar = new object();
	object baz = new object();

	Switch<object>.On(baz)
		.Case(x => x.Equals(foo), () =>
		{
			Console.WriteLine("came into foo case");
		})
		.Case(x => x.Equals(bar), () =>
		{
			Console.WriteLine("came into bar case");
		})
		.Default( () =>
		{
			Console.WriteLine("came into default case");
		})
		.Go();
}

The output from the above, is as you’d expect, the default case, since baz wasn’t equal to foo or bar.

Implementation

public class Switch<T>
{
	private T _target;
	private List<KeyValuePair<Predicate<T>, Action>> _cases;
	private Action _default;

	public static Switch<T> On(T target)
	{
		return new Switch<T>(target);
	}

	public Switch(T target)
	{
		_target = target;
		_cases = new List<KeyValuePair<Predicate<T>, Action>>();
	}

	public Switch<T> Case(Predicate<T> @case, Action action)
	{
		_cases.Add(new KeyValuePair<Predicate<T>, Action>(@case, action));
		return this;
	}

	public Switch<T> Default(Action action)
	{
		_default = action;
		return this;
	}

	public void Go()
	{
		foreach(var @case in _cases)
			if (@case.Key(_target))
			{
				@case.Value();
				return;
			}
		if (_default != null)
			_default();
	}
}

The only part I don’t really like is having to kick it off with the Go() at the end. Any ideas for a better way to kick it off, or at least a better name for it (instead of Go).

Feedback? Ideas?

Update

Paul had a great idea a couple great ideas (see comments) on how to get rid of the Go() at the end, and to force Default to only appear at the end. Here is the new implementation. Usage is the same, just remove the Go().

public class Switch<T>
{
	private T _target;
	private bool _alreadyMatched;

	public static Switch<T> On(T target)
	{
		return new Switch<T>(target);
	}

	public Switch(T target)
	{
		_target = target;
		_alreadyMatched = false;
	}

	public Switch<T> Case(Predicate<T> @case, Action action)
	{
		if (!_alreadyMatched && @case(_target))
		{
			_alreadyMatched = true;
			action();
		}
		return this;
	}

	public void Default(Action action)
	{
		if (!_alreadyMatched)
		{
			_alreadyMatched = true;
			action();
		}
		return this;
	}
}

However, I was greeted with this (and I can’t seem to get anything other than this at the moment).  Yes, I tried pressing reload or going to another page… didn’t work.

That flat-out stinks (not because I personally can’t use it, but because I’ve got no idea what to do to fix it, or what went wrong).  Do I have to restart first?  Do I have to install some WebKit thing first?  Do I have to <insert other thing I shouldn’t have to do here> first?

Maybe I’m just clueless, but this was a bad first impression.

Here is how to change the tool VS 2kX uses to do diffs/merges when hooked up to TFS (note that these are my settings for using winmerge for ALL file types):

Go To: Tools/Options/SourceControl/Visual Studio Team Foundation Server/Configure User Tools

Click “Add…”
Extension:  .*
Operation: Compare
Command: C:\Program Files\WinMerge\WinMergeU.exe
Arguments: /e /wl /dl %6 /dr %7 %1 %2
Click “Add…”

Extension:  .*
Operation: Merge
Command: C:\Program Files\WinMerge\WinMergeU.exe
Arguments: /ub /dl %6 /dr %7 %1 %2 %4

The winmerge command line reference can be found here.