Brownie Points: Blog

What I'm Working On

Sat, 30 Aug 2008 21:38:34 GMT

Here's a screen shot/teaser of "Flow", a pet project of mine.

It may not look like much, but it's deceptive. Seeing it in action is a totally different experience. I'm not quite ready to show that to you though :P

PnP Design for Operations

Wed, 27 Aug 2008 06:04:29 GMT

So while I was testing out "Flow", I came across a link to a Patterns and Practices project that I hadn't seen before called Design for Operations. Basically, this project provides guidance and tools for placing instrumentation and management hooks into your application so that it can work with System Center and other management tools. There have been a number of times where I thought it would be nice to add this kind of functionality into an enterprise app and leverage the capabilities of SCOM (formerly MOM) to provide rich management and metrics; but I didn't have a clue where to start. This package looks like it would give a huge jumpstart into doing just that.

Turn Off Vista Autotuning

Tue, 26 Aug 2008 17:27:34 GMT

If you have an older router, Vista's network auto tuning feature will cause it to get confused. Some suggest turning off Stateful Packet Inspection (or SPI) on the router will fix the issue. Others say updating the firmware will work. If your router does not have an option to turn off SPI or you do not want to do so, or if your router manufacturer no longer provides firmware updates, the last option is to turn off autotuning.

Here's the magic command line to do so:

c:\>netsh interface tcp set global autotuninglevel=disabled

I recently rebuilt a laptop and had a hard time finding this solution again. Now it's documented in a well known place for me (and you as well).

LiveID SDK

Fri, 22 Aug 2008 17:45:29 GMT

I'm trying out the sample app in the Windows Live ID SDK.

NDepend

Thu, 14 Aug 2008 13:58:02 GMT

Recently, Patrick Smacchia dropped by and left a note showing how he used NDepend to see numerically what has changed between 3.5 and 3.5 SP! This prompted me to look a little closer at the tool. If you want to capture metrics on your .NET code, NDepend does a great job at doing it.

Similar to the capabilities that TestDriven.NET gives to the lower entries in the Visual Studio product line in the arena of Unit Testing, NDepend provides code metrics for those who aren't using Team System. I would argue it goes a bit beyond the built-in Team System code metrics tools. NDepend has a query language called CQL that allows you to specify what metrics are important to you and what your alert levels are for those metrics.

There is a lot to explore in this area, especially when looking at continuous integration and build verification. Before I even spend my time looking at code for a review, I can have NDepend look over the code and tell me what's missing. Once I've made the queries, NDepend will consistently catch code that breaks my rules. Giving me more time to focus on building another O/RM.

VS2008/.NET Framework 3.5 SP1 Coming Soon

Fri, 08 Aug 2008 14:18:39 GMT

According to this blurb on MSDN Subscriber Downloads

the VS2008/.NET 3.5 SP1 download will be available on the 11th. Some people have noticed that SQL Server 08 installs .NET 3.5 SP1. So it's almost here. I played around with the SP1 beta and liked what I saw. So it's going to a tough weekend for me.

SQL Server 08 Get It While It's Hot

Thu, 07 Aug 2008 06:18:00 GMT

The final piece of the 2008 Launch, SQL Server 2008 (formerly known as Katmai), has finally gone Gold. For those with an MSDN subscription, you can download the bits now on subscriber downloads.

I'm not the person to ask for a full-blown tour of Katmai, but some of the features that have had my radar pinging include:

Spatial Data: With native support for geographic data, SQL 2008 provides a powerful platform for storing and retrieving your data based on location.
Separate Date and Time Data Types: If you're only concerned about a date, you no longer have to store it as August 6, 2008 12:00:00.00 AM. Likewise if you're only concerned about a given time (for instance if you want a recurring appointment to happen every day at 10:00 AM), you no longer are burdened with specifying a date in addition.
Table Value Parameters: Table value parameters allow you to pass a table of data into a stored procedure. While you could emulate the same effect using XML in SQL Server 2005, native support for passing in tabular data means your stored procedures do not have to deal with parsing XML or complicated XQuery.
HierarchyID: This is an interesting beast. It is a system defined SQL-CLR data type that can be used as a column type in your table. Basically the HierarchyID allows you to store a hierarchical relationship between rows in your table. (Look for an update to the Employees tables in the Northwind samples to demonstrate how to take advantage of this new feature).

There are a number of other new features in SQL Server 2008 and we haven't even left the realm of the database engine itself. Reporting Services (including a server that does not rely on IIS), Analysis Services, and Integration Services have all received significant upgrades.

I guess this gives me a nice toy to play with while waiting for the release of .NET 3.5/VS 2008 SP1.

Fixing WPF Command Routing

Sat, 26 Jul 2008 03:58:27 GMT

Bill Kempf, a fellow WPF Disciple, was lamenting the fact that by default a CommandBinding can only refer to a handler defined in the code behind of the Window/Page/UserControl in which it's defined. He wished that a syntax similar to the following was possible

<Window>
    <Window.CommandBindings>
        <CommandBinding Command="foo:MyCommands.FooCommand" Executed="{Event Target={StaticResource MyPresenter}, Handler=OnFooCommand}"/>
    </Window.CommandBindings>
</Window>

I took that scenario as my starting point. The first issue I saw was that I needed a markup extension that let's you specify a Target Object and the name of a handler on that Target returning a ExecutedRoutedEventHandler. So I made one.

The Markup Extension exposes two properties: Target (of type object) and Handler of Type String. The ProvideValue override (shown below) uses reflection to get a handle on the function and creates a lambda that invokes it for the result. (I love lambdas as much as I loved anon functions before them.)

public override object ProvideValue(IServiceProvider serviceProvider)
{
    ExecutedRoutedEventHandler retval=null;
    if (Target == null)
    {
        throw new Exception("Target cannot be Null.");
    }
    var type = Target.GetType();
    var function = type.GetMethod( Handler, new[]{typeof (Object),typeof (ExecutedRoutedEventArgs)});
    if (function != null)
    {
        retval = ((obj, args) => function.Invoke(Target, new[] {obj, args}));
    }
    return retval;
}

So I plug my new markup extension into a sample window, anticipating some good command routing lovin'. Of course it's never as easy as it looks at first. The Executed property on CommandBinding, although an event, expects a string in markup (the XAML compiler does some trickery to turn the string into an event handler). Well I know, I'll create an Attached Property to do my magic...

(To be continued...)

Generic Extension Methods

Sun, 20 Jul 2008 12:35:28 GMT

I've discovered that if an extension method is generic and the generic type is used as the "this" parameter, you do not have to write out the generic discriminator. The compiler is smart enough to infer it for you. For example, the range validation function I shared a few weeks ago can be called like so:

int myInt=5;
myInt.ValidateRange(2,20);

Jeff would be happy.

Frameworks! Frameworks! Frameworks!

Fri, 18 Jul 2008 18:36:56 GMT

If I haven't blogged about t before, I meant to but have been extremely busy. The first release of Prism or Composite App Guidance for WPF is available. Oh wait...I've blogged about it already (Did I mention how much I love Live Writer?). If you're looking at WPF for enterprise "Line of Business" applications, you should really look at it, not just for the framework but for the guidance assets themselves. I participated in the advisory board for the guidance and had a blast giving feedback to the PnP team and seeing that feedback integrated into the package. I even got my name on the MSDN page for the package

It's the little things that make me smile :P

Anyway, this post isn't about me. It's about some cool announcements coming from Microsoft. (Slow down guys or there won't be much left to announce by the time PDC arrives.) First up is the Managed Extensibility Framework or MEF for short. The short explanation for it is native Dependency Injection in the .NET Framework. There is a CTP available for it, which I'm downloading as we speak.

Next on the list is the upcoming second edition of Framework Design Guidelines. The first edition is a book that I recommend that anyone doing significant .NET development have on their shelf...within easy reach. Krzysztof Cwalina, Brad Abrams, and others on the Framework team have continued to provide addenda for the book. But there has been a major release of the framework since the first edition was published, and there is enough new stuff to talk about to merit a new edition. I've already got it pre-ordered.

Speaking of the MEF and the PnP team, Glenn Block recently announced his move from PM for PnP to PM on the MEF team. I can't think of a better person to provide leadership for this initiative.

I'm Going to PDC

Thu, 17 Jul 2008 13:01:37 GMT

I'm all set. My hotel is booked, flight is selected, and registration is done. Now all I have to do is wait and speculate. This will be my first PDC, so I'm pretty excited about it. Although Microsoft has revealed some of the topics to be discussed, the fun part is guessing what they aren't telling us yet:

With guaranteed coverage of "Rosario", I'm pretty sure they'll be talking about .NET 4.0 (and hopefully Acropolis). The initial previews were very promising. To have it become a native part of the .NET framework is exciting.

I'm also hoping to get a sneak peek at Windows 7. Server 2008 and Vista are major advances in the Windows platform. I know there is a lot of groaning about the UAC, and drivers, and blah, blah, blah. Personally I like Vista a lot (and love Server 2008 even more). I can't wait to see what's in the pipe for the next revision.

I definitely want to see what's in store for Team Edition for Architects and the new TFS/Team Explorer functionality. Full UML support will be huge for me. Hierarchical work items is a plus as well.

Live Mesh looks very captivating to me, and I can't wait to get my hands on some programmable bits.

I'm also looking forward to meeting some of the names that I know in the .NET community. And of course watching Charles Petzold's presentation at the pre-conference. What are you excited about?

Shadow Copies Saved My Life

Tue, 08 Jul 2008 16:13:09 GMT

I'm a control freak...when I delete something, I want it gone like now. I don't want it to go to a recycle bin so I can retrieve it later. Get off my computer...NOW. So when I delete a file, I always use Shift+Delete to bypass the "send to recycle bin" phase. That has bitten me in the butt a few times in the past. Thanks to Vista's shadow copy service, I have been able to recover from over zealous deletion twice now. Once with a source tree with changes I hadn't committed to source control yet. And just now with the entire contents of my downloads folder.

I may sound like one of those commercials that you see where people give "real" testimonials about how good a product is. But believe me, if you've ever wished you could undo a delete, shadow copies are the next best thing to having a rewind button for life.

Returning to the Motherland

Tue, 24 Jun 2008 16:44:23 GMT

As I mentioned before (I think), my focus on UI development has been a recent phenomenon in my career. Prior to that, the majority of my efforts has been in back-end frameworks and integration. Even looking at what I've done in the WPF arena, most of my attention has been on creating utilities that do a lot of behind the scenes work: MVPoo, Commands, Attached Properties, and all that fun stuff. I guess it's only natural that I land back in the arena of back-end and framework development. I've got a few interesting classes and utilities to share from my recent excursions in the area. Hopefully, someone will find these useful.

First up are a couple of extension methods for range validation. Right now, they only work on IComparable<T> (which all value types derive from). Being extension methods, they only work with .NET 3.5 but it is an easy exercise to change them to standard static utility methods. The interesting bit I discovered writing these is that extension methods can be Generic. The unfortunate part is the redundancy required here...something that Jeff Atwood would probably frown upon. Here is how the method would be used:

int tmpInt=45;
bool isValid=tmpInt.ValidateRange<int>(25,50);

The ValidateRange methods (I overloaded the function so that a caller can specify whether the range should be inclusive) take the type of the object being validated as a type parameter so that it can pass it to IComparable<T> and strongly type the min and max parameters. I guess I could just use the non-generic IComparable interface instead of IComparable<T>, but then you'd lose the compile time verification.

Anyway, the code is attached below. Let me know what you think.

Technorati Tags: Extension Methods,Validation,Range Validation,C#

Prism Becomes Composite Application Guidance for WPF

Fri, 20 Jun 2008 05:50:39 GMT

Or CAPPG for short. I had the pleasure of participating on the advisory board over the past few months. I think the biggest boost to my ego came when I saw the Delegating Command captured as a best practice by the PnP team.

Prism (there was an acronym there but I forgot what it is) is a new guidance framework, in the vein of the CAB, SCSF , and WCSF, that captures best practices from the pioneers in the wild west of WPF development. (Remember WPF is still considered to be in the early-adopter phase.)A lot of the writings of Josh Smith, Dr. WPF, Dan Crevier , and others has been captured in this framework (which is still, according to the team, a work in progress). I have my own work that is soon to be in progress and will use Prism to take it through its paces.

If you will be doing any significant WPF development in the near future, it couldn't hurt to evaluate Prism. Here's the link.

The Best Part of Blogging

Mon, 02 Jun 2008 17:16:39 GMT

You get to look back at your old posts in astonishment at how far you've come from back then. Take Paul Stovell for example.

In March of 2006 he gave a presentation called "Why I hate Data Binding"

In July of 2007 he gave a presentation called "Binding Oriented Programming"

Talk about an about face! I don't have any drastic examples like that in my blog. But it's still fun to read through some of my old posts.

You ARE in the Software Business

Thu, 08 May 2008 12:25:18 GMT

I've spoken a lot about the potential that Team Foundation Server provides as a framework for creating very powerful software development process tools. I've also spoken a lot about supporting your software development department with a dedicated development team. These two ideas go hand in hand. Let me expand on that here.

When a company wants to support their business processes with software, they have two choices: buy a product off the shelf; or build a custom software solution. Actually, there are three choices, but the third is a hybrid of the first two: customize an off the shelf product.

The software your company creates for the sprocket order fulfillment system is an electronic manifestation of your company's business processes. You have significant amounts of money set aside every year to improve that software so that it better captures your business processes. You know that COTS software won't be an exact fit for what you are doing, your processes are what give you an edge over the sprocket factory down the road.

Why is it that companies are so quick to segregate software development from the rest of their business? "IT supports the business, it's not a core business process." "We're not in the software business, we're in the sprocket business."

Stop it! It's time to come to terms with reality that if you are spending money to develop your own software or to customize off the shelf software, YOU ARE IN THE SOFTWARE BUSINESS. Even if the only consumer of your software is you. Once you've accepted that fact, you'll realize that software development is a core business process. Do you see where I'm going here? We take it for granted that an off the shelf product is good enough for developers. You don't know how many times I've heard people complain "if only visual studio did this" or "I wish TFS was easier to work with." Sound familiar to the same complaints you hear about the CRM tool your company just bought? The big difference is that code gets written to address the shortcomings of the CRM solution. Whereas Visual Studio and TFS get to stay as they are and development teams are trained to "work with the system." When was the last time you've heard of a company (other than a software vendor) having a project dedicated to creating tools that improve the software development lifecycle?

Why spend so much money creating software that captures all of your business processes except the one that makes the rest possible? And if you don't think that improving your software development process isn't as important as your "core business", you'll quickly be left behind when that sprocket factory down the road figures it out.

Attached Properties for Max Column Width

Tue, 06 May 2008 22:31:26 GMT

Laurent Bugnion (a fellow WPF Disciple) just wrote a post showing one way to add MaxWidth capabilities to the WPF GridView. William Kempf (another disciple whom I had the pleasure of meeting when I gave my presentation at Indy Code Camp), suggested that Laurent use an attached property to allow the feature to be XAMLized.

I thought it would be a good idea. So I fired up VS and wrote a little bit of code. If you've read my posts on using the remora pattern then you know the gist of the setup (if not go see them here). Laurent jumped through a few hoops to hook into the drag event of the GridViewColumnHeader resize thumb control. I found out that GridViewColumn implements INotifyPropertyChanged so on a whim decided to check if I can catch a Property changed event when the Width is changed. Lo and behold I could. So I checked if I could do a poor man's CoerceValue and surely enough I was able to do that as well. I couldn't think of a better place to put it, so I checked the code into the WPF Toolbelt (along with a few other changes). This makes the first check-in since September of last year. I just reorganized some namespaces and stuff...it took me a while to get reacquainted with the code. But I will be performing more work on it in a while. Download the code from Skydrive (only have the MaxWidth attached property now...MinWidth isn't much harder though).

You'll Grow Out of It

Wed, 12 Mar 2008 05:55:19 GMT

I followed the instructions for an interesting meme that I found on Eric's blog and came up with the album cover you see to the left. Here are the original links if you're interested:

The Picture

The Quote

The Article

I took artistic license and named my band just Wyoming County, but it the recipe works pretty well. The funny thing is...the title is somewhat appropriate. I think I have grown out of my current space and have already taken up residence in a new environment. I will begin moving my old content over (someone remind me to keep local copies of my blog posts for the next time I want to do this), and adding new content to the main domain. In the interim, it will just host Brownie points. So what are you waiting for? My latest post is waiting for you right here

The Problem as I See It

Wed, 23 Jan 2008 00:45:41 GMT

I remember helping a developer who was attempting to transition from C to C++. Because valid C is valid C++, it was difficult to get the point across to him that -- even though it worked -- it wasn't necessarily the best way to do things. It takes a concentrated effort for someone to unlearn bad habits.

For an example look at Winforms programming. It is dead simple to drag a few controls onto a form and wire it up to perform business logic on a button click. I must confess I've done this myself, even as recently as last year (oh wait it's 2008 now make that the year before last). It took me struggling with WPF to realize that even though it "worked" that was not the best way to wire up my UI (in all but the simplest of cases). I decided to explore the benefits of the Model-View-Controller Pattern (or MVC for short) for my application development. I knew of this design pattern's existence but had never bothered to implement it explicitly in my development. As I got my feet wet with using MVC for my WPF UIs, I started noticing a lot of benefits.

Actually let me correct myself. I didn't consciously decide when I first started coding in this manner that I was going to use the MVC pattern. I just decided to remove the logic of deciding what controls were enabled, how to initialize the UI, and how to validate the data entered into the form (among other concerns) away from the Window/UserControl and into a helper class that worked with the UI while shielding it from the intricacies of how the system works.

Once I looked at what I had done, I finally realized that I had implemented a variation on the MVC pattern. I had read some of Dan Crevier's blog postings regarding what he called the Model - View - ViewModel, or MVVM, pattern (itself a refinement of the MVP pattern) prior to this so I guess it had laid dormant in my subconscious until I needed it.

I have come to realize that going from basic "Forms and Controls" (as Martin Fowler calls it) UI development to MVC is a paradigm shift on the magnitude of going from procedural development to object-oriented development (e.g. C to C++). Although the same development techniques that make Winforms (and VB before it) development so approachable still "work" with WPF, the framework really shines when you move to an MVC architecture for your UI. Once you grok this concept, you'll find that you'll hesitate to write even simple applications without using it.

Dynamic Dependency Properties

Thu, 03 Jan 2008 01:36:01 GMT

First things first. I'd like to wish everyone a Happy New Year. Here's hoping that 2008 brings with it happiness, excitement, joy, and wonder!

Recently I came across a blog post that discussed the use of Custom Type Descriptors to dynamically add properties to an object. We currently use this technique in our application, however there is a lot of hocus pocus going on behind the scenes that makes working with that particular piece of code precarious.

I was curious if it would be possible to dynamically declare dependency properties and bind to them using the WPF Binding system. The short answer is yes. The long answer is HELL YES! Believe me using dependency properties to dynamically add properties to your objects is orders of magnitude easier than using custom type descriptors. Something tells me that DPs are just an abstraction of custom type descriptors. Does that make me lazy? Probably. Then again, the less code I have to write to accomplish a task, the less likely I am to introduce bugs, and the quicker I can get to the next task. And as we all know, "programming is fun, but shipping is our job." Besides, you want to trust me on this one...programming Custom Type Descriptors is not fun.

Of course you, my dear readers, are probably wondering, "Why would I want to dynamically register dependency properties?" Isn't the whole point of a dependency property to allow you to bind to it at design time? Well not only does Mabsterama give a great scenario with the role provider, but there is a well known data modeling pattern known as Entity Attribute Value. I just ran into a post in the forums (which are finally working properly again) where the poster appears to be in need of a similar solution. This encouraged me to finish this post.

My solution relies on a simple class that I call the DependencyPropertyRegistry. The DependencyPropertyRegistry is responsible for dynamically registering dependency properties against a DependencyObject descendant and keeping track of the properties so they can be manipulated. The second part of the solution is a class that wants to dynamically expose properties for binding. The final piece of the puzzle is a control that knows how to properly configure the bindings and display them.

This is easiest explained through code, but I have to do some scrubbing before I can share it with you guys. I promise it will be worth the wait.

How "Cider" Saved the Day

Wed, 19 Dec 2007 21:18:03 GMT

Or "My New Favorite Feature of the WPF Designer"

So I'm giving a quick presentation of my favorite new feature in VS 2008 at the Wisconsin .NET User Group Installfest, and because I hadn't actually prepared for the presentation in advance, Murphy's Law is in full effect. My normally snappy computer is crawling through the simplest of tasks (because I'm on battery power save mode). I'm floundering here and want to hurry and finish the demonstration (the "Cider" WPF designer). So now I'm standing in a pool of my sweat, I can't even see because the saline is dripping into my eyes. And I have to remember the syntax for importing a CLR namespace. I look to a familiar face "Quick what's the syntax for importing an assembly for reference in XAML?" Travis looks back at me with a blank stare. So I start typing hoping that something will pop in my head when I see:

At that very moment, I felt that Team Cider had put this feature in there for this very situation. I stated emphatically...well there you have my new favorite feature!

Overall the meeting was great. The turnout was HUGE. We had an assembly hall filled with people ready to install VS2008 (Professional this time as opposed to the 2005 launch when they gave out Standard). I forgot my full camera and for some reason, I can't email the pictures from my phone so I'll refer you to Larry Clarkin.

Hands down the best mini demo in my eyes was the demonstration of the code metrics capabilities of the VS 2008 Team Editions, the presenter of that feature won a copy of SceneIT! for the Xbox 360. Brennan won an 8 GB Zune for his presentation. There were a ton of toys donated in exchange for a raffle ticket. The winner got an Xbox 360 Elite with Halo 3 Limited Edition (not Legendary). And the food spread was fantastic. Especially the nacho toppings...chili and queso dip poured over tortillas is delicious! Overall, it looks like everyone enjoyed themselves. At the very least they got a free copy of VS 2008 Pro.

You Like Me...You Really Like Me!

Thu, 13 Dec 2007 03:07:49 GMT

Today I got a special package in the mail. It was pretty heavy. At first I wondered what it could be. Then I remembered receiving an email a few weeks back from Microsoft asking me to make sure my connect profile was complete for a special gift.

What a nice note! Here's the text:

Visual Studio 2008 and .NET Framework 3.5 are joining the ranks of the best releases we have ever shipped. I am incredibly proud to be a part of the team that is truly advancing the state of developer tools. We could not have done this alone and I wish to thank you for the valuable feedback you provided.
The importance of the community and early adopters in providing feedback as we built Visual Studio 2008 and .NET Framework 3.5 cannot be understated. You made the product better, working closely with us through the product development phase by submitting bugs, providing feedback on what features deliver value, and making sure we are building the right products for our customers. It is always our goal to enable you to be outstanding developers by bringing you the best quality product with the features you need. Community contribution is invaluable in helping us to achieve that goal and deliver these great products.
To show our appreciation, please accept our thank you gift. Thank you again for helping us deliver an amazing Microsoft Visual Studio 2008 and .NET Framework 3.5
All the best,
S. Somasegar
Corporate Vice President,
Microsoft Developer Division

The cube is one of those Laser Etched paperweights with the Visual Studio 2008 and .NET Framework Branding and a quick "Thank you for the lasting contribution you made to Microsoft Visual Studio" S. Somasegar. All of that for submitting a few bug reports. No, Soma, thank you, for making a geek feel important.

Snoop, Woodstock, and Mole

Wed, 12 Dec 2007 02:15:40 GMT

Once again, I've been assuming that everyone in the WPF community already knows what I know. Funny thing is, I haven't seen heavy coverage for Woodstock and Mole. Put simply, if you are developing in WPF, you owe it yourself to go right now and download Mole. For a little background, Mole is the successor of Woodstock, which is the spiritual successor to Snoop. For an understanding of Snoop, think UISpy or Spy++ for WPF. Now take Snoop and turn it into a Visual Studio debugger visualizer so you can drill into your visual tree on a breakpoint, and you have Woodstock.

Now take Woodstock and put it on steroids, and you have Mole. Like I said, you owe it to yourself to get it NOW.

What's Cool About VS2008: Extension Methods

Tue, 11 Dec 2007 08:06:50 GMT

What Are Extension Methods

Extension Methods are a new feature in C# 3 and VB 9. To put it concisely, an extension method is a static helper function that can be invoked as if it were declared on any object that has a type matching that of its first parameter. It's pure syntactic sugar. Extension methods basically allow you to change this:

List<String> injuredSecondary = new List<String>
{
  "Mike Brown",
  "Nathan Vasher",
  "Charles Tillman"
};
//Note that select is a static method on the System.Linq.Enumerable class
IEnumerable<String> namesake = Enumerable.Select(injuredSecondary, x => x == "Mike Brown");

To this:

List<String> injuredSecondary = new List<String>
{
  "Mike Brown",
  "Nathan Vasher",
  "Charles Tillman"
};
//Note that we are calling select as if it were a method defined on the injuredSecondary object.
IEnumerable<String> namesake = injuredSecondary.Select(x => x == "Mike Brown");

As the code shows, the Select function is defined on a class called Enumerable (in the System.Linq namespace). However the C# compiler lets you reference it as if it were declared on IEnumerable itself. The methods appear to extend IEnumerable without requiring a new IEnumerable interface to be created.

Digging Deeper

The previous statement should give a big hint as to why extension methods even exist. Let's say you've made a framework or library that is intended for use by other developers. The library has been a huge success, with millions of developers using it. Lets also say that there is an interface within your library that is used practically everywhere within your framework as well as by those millions of developers. Finally, let's say that you want to add new functionality to that interface in your new library release. You have four options (in order of desirability):

Add the new functionality to the interface directly. This immediately breaks the existing implementations (because as you know interfaces are purely virtual, they can only declare method signatures, and cannot provide implementation).
Extend the interface, this doesn't break existing implementations, but users of your library can't automatically benefit from the new features.
Implement your extensions as helper functions allowing users of your library to access the new functionality if they want, or ignore it if they don't OR:
In addition to 3, if you also control the spec for the languages that leverage your framework, enhance the language to provide a syntax whereby static helper methods can be invoked as if they were declared directly on the object.

By adding the extension method syntax to C# 3 and Visual Basic 9, Microsoft was able to extend IEnumerable without breaking IEnumerable. Quite a feat if I must say so myself. The great thing is that we get the same power in our hands so without further ado. Let's look at a sample.

Intersecting Rectangles

Let's say we have two rectangles defined by the System.Windows.Rect structure; and we want to determine if they overlap or not. We could write the code that does it inline, or we could refactor it out to a helper method that takes two rectangles and compares them. Even nicer would be if we could add a convenience method to Rect that does the check for us. Of course the problem is that extending Rect means that it can no longer be a structure. Extension methods to the rescue. Here is the definition of an extension method that does what we want. (Code not optimized for clarity's sake).

    public static class Extensions
    {
        /// <summary>
        /// Determines if two <see cref="Rect"/>s overlap each other
        /// </summary>
        /// <remarks>
        /// The order of subject and target do not matter.
        /// </remarks>
        /// <returns>True if the Rectangles overlap, false otherwise.</returns>
        public static bool Overlaps(this Rect target, Rect subject)
        {
            Double innerRight = Math.Min(target.Right, subject.Right);
            Double innerLeft = Math.Max(target.Left, subject.Left);
            Double innerBottom = Math.Min(target.Bottom, subject.Bottom);
            Double innerTop = Math.Max(target.Top, subject.Top);
            return innerRight > innerLeft && innerBottom > innerTop;
        }

    }

There are a few things to note here. First you'll notice the 'this' keyword being used in the signature for overlaps. In this case 'this' tells the compiler that the function can be used as an extension method on any variable of type Rect. Slightly less out of place, but still significant is the fact that the Extensions class is declared static itself. Extension methods can only be declared in static classes. Below is the unit test for the Overlaps function. What it doesn't show is one final point: to use an extension method, you must import the namespace in which the method is declared.

        /// <summary>
        ///A test for Overlaps
        ///</summary>
        [TestMethod()]
        public void OverlapsTest()
        {
            //A rectangle overlaps itself
            Rect target = new Rect
            {
                Location = new Point { X = 0, Y = 0 },
                Size = new Size { Height = 20, Width = 40 }
            }; 
            Assert.IsTrue(target.Overlaps(target),"A rectangle overlaps itself");
            Rect subject = new Rect
            {
                Location = new Point { X = 40, Y = 0 },
                Size = new Size { Height = 20, Width = 40 }
            };
            //Rectangles that share an edge do not overlap.
            Assert.IsFalse(
                target.Overlaps(subject),
                "Rectangles that share an edge do not overlap.");
            Assert.AreEqual<bool>(
                target.Overlaps(subject), 
                subject.Overlaps(target),"Overlaps is Symmetric",subject,target);

            subject.Location = new Point { X = 10, Y = 5 };
            subject.Size = new Size { Height = 10, Width = 20 };
            //Rectangles overlap when one is entirely inside the other.
            Assert.IsTrue(
                target.Overlaps(subject),
                "Rectangles overlap when one is entirely inside the other.");
            Assert.AreEqual<bool>(
                target.Overlaps(subject), 
                subject.Overlaps(target), 
                "Overlaps is Symmetric", subject, target);
            
            subject.Location = new Point { X = 30, Y = 15 };
            //Rectangles overlap when one is partially inside of the other.
            Assert.IsTrue(
                target.Overlaps(subject), 
                "Rectangles overlap when one is partially inside of the other.");
            Assert.AreEqual<bool>(
                target.Overlaps(subject), 
                subject.Overlaps(target), "Overlaps is Symmetric", subject, target);

            subject.Location = new Point { X = 100, Y = 500 };
            //Rectangles do not overlap when they share no points in common.
            Assert.IsFalse(
                target.Overlaps(subject), 
                "Rectangles do not overlap when they share no points in common.");
            Assert.AreEqual<bool>(
                target.Overlaps(subject), 
                subject.Overlaps(target), "Overlaps is Symmetric", subject, target);
        }

Nutritious AND Delicious.

Extension methods are a powerful tool for your arsenal. If you're doing framework/systems coding, I'd recommend that you definitely look at using extension methods rather than derivation when possible when targeting a .NET Framework class (like Rect). In the case of Rect, you get the added benefit of keeping it as a structure rather than requiring it to be a class. In general, it allows users of your framework to take advantage of its capabilities without changing their object model hierarchy.

For those wondering, no I'm not leaving the WPF trail. This was just a tangent that I decided to talk about while writing something else about WPF. More of the usual will be headed your way soon.

Silverlight 2.0 AKA Heaven on Earth

Fri, 30 Nov 2007 02:33:37 GMT

From Scott Guthrie's announcement:

WPF UI Framework: The current Silverlight Alpha release only includes basic controls support and a managed API for UI drawing. The next public Silverlight preview will add support for the higher level features of the WPF UI framework. These include: the extensible control framework model, layout manager support, two-way data-binding support, and control template and skinning support. The WPF UI Framework features in Silverlight will be a compatible subset of the WPF UI Framework features in last week's .NET Framework 3.5 release.

I figured that Silverlight would get better by the time of release, so this doesn't surprise me much. But I see more bullet points that attract my eye. Reading further:

Rich Controls: Silverlight will deliver a rich set of controls that make building Rich Internet Applications much easier. The next Silverlight preview release will add support for core form controls (textbox, checkbox, radiobutton, etc), built-in layout management controls (StackPanel, Grid, etc), common functionality controls (TabControl, Slider, ScrollViewer, ProgressBar, etc) and data manipulation controls (DataGrid, etc).

I'll refrain from sullying your screen with the filth that spewed out of my mouth when I read this (ESPECIALLY the bit about the built in DataGrid); but it was pretty much a recreation of the scene in Boondock Saints when Roc discovered that the McManus brothers had killed a room full of Russian Mafiosi (just discovered that word is the plural of Mafioso thanks to Live Writer). Back on subject, this is nothing short of amazing news! Let's not forget the fact that this release will run on Macs and Linux. Add in the networking APIs and BCL support (including LINQ) and you have a compelling development platform. Excluding the WPF 3D library, Silverlight 2.0 will essentially live up to the original Silverlight codename and be WPF Everywhere.

Oh here was the killer! Silverlight 2.0 will go into Beta soon with Go Live license!

Scott's post has some stuff in there about ASP.NET and Ajax and stuff...but I wasn't really listening to all that. It sounds good and all but not half as thrilling as the Silverlight news. Adobe who?

Just a Note

Mon, 19 Nov 2007 20:46:10 GMT

MSDN Subscriber downloads has slowed to a crawl today. That can only mean one thing...if anyone is sucessful in logging in and verifying, let me know.

Edit: no confirmation needed. http://msdn2.microsoft.com/en-us/vstudio/default.aspx

Acropolis No More Soon to Be in .NET Framework Core

Tue, 30 Oct 2007 04:14:55 GMT

So my powers of observation are proven right again...I'm not sure if I actually blogged it, but I did mention to a few people who can verify that I believed "Acropolis" would become a part of .NET Framework proper. After a bit of silence, Microsoft has finally announced the plans for "Acropolis". Basically, a future version of the .NET framework will indeed include a smart client equivalent of the ASP.NET MVC framework. Once again, I implore the kind people of Microsoft to consider providing a unified framework for application composition.

In other great news, MSFT will be enhancing the existing PNP Guidance to fill the void between now and the release of "Acropolis" (which will have no further preview releases) within a future version of the .NET Framework (fingers crossed hoping that it makes 4.0).

Supporting Input Binding for the Delegating Command

Thu, 18 Oct 2007 12:00:05 GMT

So after some research, I discovered what it takes to support Input Binding (E.G. key gestures) for the Delegating Command: absolutely nothing. Although you can configure a Routed Command's Input Bindings using the Command Manager, you can also do it in XAML using UIElement.InputBindings like so:

<Window.InputBindings>
<KeyBinding Key="B" Modifiers="Control" Command="ApplicationCommands.Open" />
</Window.InputBindings>

Here's the really fun part. You can configure Input Bindings for any ICommand (like a Delegating Command exposed as a property on your View Model (or Acropolis Part)). In all honesty, I'm seeing less and less use for Routed Commands. I for one won't be using them going forward.

It's time for us to begin sailing the 4C's again. I've just dusted off Part Two of Code Climber Custom Controls and it's going to be a doozy just like it's predecessor. It just needs one more evening/morning writing cycle to complete.

Brownies and Cookies

Wed, 17 Oct 2007 18:53:35 GMT

Dr. WPF suggested in a WPF forum thread that I hand out Brownies as awards. I haven't made a badge for the recipients to display on their Web sites yet, but I think these awards are overdue. So here comes the first batch of Brownies for those individuals (sorry no companies) who have made significant contributions or discoveries within the WPF community (or in some cases did something that just make you go Wow!). They are in no particular order.

Dr. WPF as of right now he is the lead answerer in the WPF Forum over the past 30 days with 116 answers. This also makes him one of the top 10 answerers in ALL of the MSDN forums. This is even more significant when you consider he is the ONLY person in the top 10 who is not a moderator (moderators can mark their replies to a question as an answer). So there you've got a Brownie, hope you're happy now.
Casey Chesnut for WPF Augmented Reality...that just rocks on so many levels.
Josh Smith for writing about 5000 WPF articles on Codeproject.com
Jeremiah Morrill for taking WPF/Win32 interop to a HOLE NUVA LEVEL!

That's it for right now. Don't feel slighted because I didn't get you this time around. There are others that I want to name but I don't want to make the list too long. On another note, I mentioned that in addition to Brownies, I would be handing out cookies for people who could be nicknamed captain obvious.

The first recipient of this dubious honor is none other than me. I made a big deal about the Delegating Command when a similar solution had already been blogged and talked about extensively. This will be the first and last Cookie handed out by me.

Congratulations to the first batch of Brownies, I will get your badges to you in short order.

The Delegating Command

Tue, 16 Oct 2007 20:25:50 GMT

The RoutedCommand doesn't quite make sense to me in the M-V-VM pattern. Why go through the effort of creating command bindings when you are holding an instance of the Command within your controller (or ViewModel). Just trust me when I say it's convoluted.

At the other extreme, you would have to create a new class for each and every Command that your application provides. While there is a benefit to this scenario in some cases, in most instances it's overkill. A happy medium is having a class that implements ICommand and exposes events for CanExecute and Execute. Hence I give you the DelegatingCommand.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Windows.Input;

namespace YourNamespaceHere
{
    /// <summary>
    /// Delegate for adding logic for determining if a 
    /// <see cref="DelegatingCommand"/> can be executed
    /// </summary>
    /// <param name="parameter">
    /// The parameter being passed to the command (can be null)
    /// </param>
    /// <returns>
    /// True if the command can be executed with the given parameter
    /// </returns>
    public delegate bool CanExecuteHandler(object parameter);

    /// <summary>
    /// Delegate for adding logic to execute a <see cref="DelegatingCommand"/>
    /// </summary>
    /// <param name="parameter">
    /// The parameter being passed to the command (can be null)
    /// </param>
    public delegate void ExecuteHandler(object parameter);

    /// <summary>
    /// The DelegatingCommand provides an implementation of <see cref="ICommand"/>
    /// that can delegate CanExecute and Execute calls to listeners. As opposed
    /// to the RoutedCommand, it does not require any custom wiring to the UI,
    /// just bind an instance to any <see cref="ICommand"/> (e.g.
    /// <see cref="Button"/> or <see cref="MenuItem"/>) using XAML. This is 
    /// useful when implementing the MVC pattern within WPF. The Controller can
    /// expose a DelegatingCommand as a property and the View can bind to it.
    /// Anyone aware of the instance can handle the CanExecuteRequested and/or
    /// ExecuteRequested events.
    /// </summary>
    public class DelegatingCommand : ICommand
    {
        public event CanExecuteHandler CanExecuteRequested;
        public event ExecuteHandler ExecuteRequested;

        public bool CanExecute(object parameter)
        {
            if (CanExecuteRequested != null)
                return CanExecuteRequested(parameter);
            return true;
        }

        private Object _Owner;
        public Object Owner
        {
            get { return _Owner; }
            set { _Owner = value; }
        }

        public event EventHandler CanExecuteChanged;

        public void Execute(object parameter)
        {
            if (ExecuteRequested != null)
                ExecuteRequested(parameter);
        }

    }

}

Never Ceasing To Amaze

Mon, 15 Oct 2007 12:47:40 GMT

I'm finally convinced that we're looking to the wrong country for off-shoring. The .NET developers down in Australia keep doing things that just make me go WOW! For instance, take Paul Stovell's new SyncLINQ demonstration. It adds ObservableCollection capabilities to a LINQ query. But wait there's more! You can also tell SyncLINQ that you want your query run in the background (allowing your UI to update as Items come in). Finally you can tell SyncLINQ to rerun your query in the background on a given interval, also updating the UI automatically. I've already got a few ideas for which I can put SyncLINQ to good use.

12th Most Important Mike Brown

Fri, 12 Oct 2007 06:28:13 GMT

So, I finally committed the ultimate act of vanity and googled myself. I was pleasantly surprised to find that my blog is ranked number 12 (just missing the first page of Mike Browns). Here's the kicker...this is the only post in my blog that has the words Mike Brown in it. Lot's of Brownies, no Mike Brown. I got to number 12 (actually higher there are some dups ahead of me) on nothing but the strength of incoming links.

While that's cool and all, what sucks is that if I leave spaces like I intended to, I have to start all over. Oh by the way if you're looking for info on WPF from a guy named Mike Brown, google says I'm number 1 (even above Chad Brown who mentions Mike Swanson in his blog. Take that Mike Brown Solutions dot com! By the way I'm way ahead of Mike Brown dot com and Mike Brown dot us. Even ahead of Mike Brown sucks dot com (boy did that get tiring when I lived in Cincinnati).

Considering that the former head of FEMA was one of the biggest pieces of news not too long ago and the others have the advantage of having ... I don't know their name on their pages (or in their domain name). And the sheer number of Mike Browns in the world...I'm happy with being #12.

Where do you end up when you google yourself?

Call To Arms

Thu, 11 Oct 2007 13:51:18 GMT

(Cross posted on the front page of the WPF Toolbelt)

I had some lofty dreams when I first started this project (during beta 2 of .NET Framework 3.0. Now the 3.5 Framework is in Beta 2 and this project has stagnated because I've lacked the bandwidth to properly contribute to it. I've had some ideas for how to get things rolling again, but I just haven't had the time to properly dedicate to this. There are commercial libraries that address the same space as the toolbelt. And I can't hope to match a team of paid developers as a single developer working in my spare time. I've had the occassional volunteer join me, however because I can't provide the bandwidth to properly lead this effort, they tend to lose steam and move on to other things.

I've seen a lot of visits to the project and a lot of downloads but very little feedback. Hopefully, the project has helped someone learn more about WPF. There are some nice examples of custom control creation in there...especially how to do lookless controls. The PowerGrid is fully stylable from the cell up. Of course I wouldn't recommend that you create a data grid as a custom control like I did. Instead I would recommend wrapping the ListView/GridView into a control that turns it into a data grid, or even using attached properties to decorate a standard listview with data grid functionality.

Going forward, I cannot maintain this project alone...especially if I'm going to do what I know I want to do with it. So I ask the people who have volunteered if they would re-invest in the vision of the project. I ask one of the 2000 downloaders if they could invest some time to make this a tool that they could really use. I ask anyone involved in the WPF community that if you want to accelerate adoption of the framework, we need something like this. I ask the heads of other projects similar to the toolbelt, let's come together and pool our efforts to make something better than any of our projects can be alone. I'm willing to put my ego aside because running a project alone is no fun.

Let's get together and make something amazing!

Slightly Dorky Nerd King

Thu, 11 Oct 2007 02:10:28 GMT

I just got my nerd certification.

I added my South Park avatar to seal the deal. I appeared to have failed my dumb/dork/awkward section...not by much though. BTW one disturbing statistic from the site is that 58% of the test takers would pick the Internet over sex if forced to choose one sacrificing the other permanently.

Popfly Invites

Wed, 10 Oct 2007 06:31:01 GMT

So I logged into Popfly to see what's new when lo and behold, I learn that I have invites. 5 to be exact. I'm reserving three of them for colleagues to have right of first refusal. I want to give two out here. (If my colleagues turn them down, I might have more.) So, what do you think would be a fair way to hand these guys out? If this doesn't get the lurkers to start posting comments, I don't know what will...well I do, but this is a family blog.

3D Programming for Windows

Tue, 09 Oct 2007 17:40:37 GMT

About a month or so ago, I got a special package in the mail that has a few of my colleagues turning green. Charles Petzold sent a signed copy of his book 3D Programming for Windows. The fact that I got a personalized copy from the guy who wrote the book on Programming Windows (literally) may bias my opinion of this book. Therefore, in the interest of full disclosure, I have revealed this fact. We don't want another scandal like what happened when Microsoft sent the decked out Acer Ferraris to key members of the blogosphere ;).

First Impressions

3D Programming for Windows comes in at just over 430 pages cover to cover. This makes it much less daunting at first glance than Applications=Code+Markup (slightly over 1000 pages cover to cover). And it makes sense. Petzold's book on the entire WPF framework has a lot more ground to cover than a book that is specific to WPF 3D. It's interesting to note that this book is the same size as WPF Unleash which includes coverage of WPF 3D within its pages.

From Wax On Wax Off to Beating Cobra Kai

If you've read the original Programming Windows, you know that Charles has a very strong grasp of Windows Graphic programming. He shows you how to create a full-featured word processor, using raw GDI calls. There was no MFC to be found there. For a person who has an interest in 3D programming but has never written a line of 3D code in his life, I found that Charles' foundational writing style made the topic very approachable for me. He begins with introducing you to the basic concepts that you will deal with on a day to day basis in 3D programming (polygons, lights, cameras). He then moves on to more involved concepts that will help you do cool things with those basic elements for example using transforms and animation to manipulate your models, or applying textures and materials to make them prettier.

For the more adventurous souls, Charles goes into how to extend the WPF 3D engine with custom transforms, even providing an example transform that he feels was missing from the framework.

Overall, I would say that Charles' book on WPF 3D is a great starting point for anyone who has been interested in using 3D but has been reluctant to because of the steep learning curve that Direct 3D has presented. With the simplified 3D library that WPF provides and Charles on your side, you'll be a 3D wiz in no time.

Hey You've Got Your WPF in My Augmented Reality

Mon, 08 Oct 2007 13:31:46 GMT

Okay this one is cooler than words can express. Mr. Cool Tech himself has gone and done it again. This time he has taken WPF 3D and made an augmented reality demo. A simple example of augmented reality is the games for the Sony eyetoy where you manipulate the game not with the controller but by motions in the real world. Coming soon is the Eye of Judgement game. A playing card game that you play using the PS3, the Eyetoy and real physical cards.

Casey decided to do something similar himself using WPF 3D and a webcam (and here we have again another LEGITIMATE reason why we need better DirectShow integration with WPF). Anyway, there's not much more I can say make the jump and prepare to be wowed!