Software

NDepend Part II - Beginning CQL

Stuart Thompson — Tue, 19 Aug 2008 18:25:12 GMT

In my continuing use of NDepend on both my work and home projects, I have been investigating CQL more and more, especially from the perspective of use in continuous integration. NDepend provides some incredibly powerful analysis features and I find the idea that constraints can be applied and warnings reported as part of day 1 builds to be extremely appealing. I'm all about keeping code clean, constrained, and consistent. NDepend provides another great tool in my kit to ensure that my own code is marshalled to my standards from the very first line that is written. As David Muhondro put so eloquently in his blog post, NDepend is static analysis on steroids. When most users encounter CQL for the first time, the response is "wow, this looks really powerful, now what does it mean?". I've started by taking the stock queries that are included in a basic NDepend project and understanding what they mean and the warnings that they are expected to generate. By understanding the warnings and their purpose in the project, I began to understand how I could tweak those queries and even write my own to enforce the rules I'd like my code to live by.

Let's start by looking at an example. After creating a new NDepend project and pointing it at a list of assemblies to analyze, the default CQL queries that are included are grouped into the following categories:

Code Quality
Design
Unused Code / Dead Code
Encapsulation
Diff / Changes / Evolution
Test Coverage
Purity / Immutability / Side-Effects
Naming Conventions
.NET Framework Usage
Statistics
Samples of Custom Constraints
Constraints extracted from Source Code

I started by looking at the Unused Code / Dead Code queries, specifically at the Potentially unused methods query. By double-clicking on the query it is opened in the CQL query editor and displays the following:

 // <Name>Potentially unused methods</Name>

WARN IF Count > 0 IN SELECT TOP 10 METHODS WHERE

MethodCa == 0 AND            // Ca=0 -> No Afferent Coupling -> The method is not used in the context of this application.

!IsPublic AND                // Public methods might be used by client applications of your assemblies.

!IsEntryPoint AND            // Main() method is not used by-design.

!IsExplicitInterfaceImpl AND // The IL code never explicitely calls explicit interface methods implementation.

!IsClassConstructor AND      // The IL code never explicitely calls class constructors.

!IsFinalizer                 // The IL code never explicitely calls finalizers.

Breaking it Down
Let's break this down a little. First of all it is important to realize that this is not SQL, despite any similarities in the syntax. The first line selects the top 10 methods that satisfy the query and then raises a warning if the total number of methods is greater than 0. The reason for the seemingly superfluous top 10 selection is that if the count is greater than zero then those top 10 will be displayed as the results of the query. To avoid swamping with noise the query is restricting to only the first ten offenders. The next line is the first part of the WHERE clause and looks for methods with an CruiseControl to bring these warning and reports into the daily life of your projects. While static analysis en masse isn't for everyone (not even for me), a small list of CQL queries can help you perform necessary housekeeping without having to do the hard hunting work yourself. The inevitable question is whether or not this overlaps with FxCop. There is some overlap, but they are both just tools from which you should pluck the best of the functionality you like and strike down the cruft that gets in the way. There are some cases where writing an FxCop rule specific to your application is a good thing, however I'm finding that writing CQL queries for warnings lends itself a little better to how I think about static analysis in the first place. The key is finding that sweet spot in the middle.

New Array of Anonymous Objects

Stuart Thompson — Wed, 09 Jul 2008 18:08:57 GMT

While coding up a couple of prototype LINQ queries this morning I came across a rather interesting syntax using anonymous types and object initializers. I wanted to show an example of using a where clause upon a property of an object but didn’t want to put a bunch of plumbing around it just to set up the example. In my head an array containing three Person objects would suffice, with each person object having Name and Age properties that I could use in my query. I wasn’t sure if this would compile but dropped it into the wonderful LinqPad and sure enough found that it compiled right away, giving me exactly the results I was looking for.

from person in new [] {
    new { Name="Bob", Age=28 },
    new { Name="Ted", Age=22 }
    new { Name="Sally", Age=25 } }
where person.Age < 26
select person

I can declare a new [] { <set of anonymous types> } right there in the query, saving me the job of creating all of the plumbing around it just for the sake of the sample. Cool!

Virtual CDRom Control Panel - Mount Failed

Stuart Thompson — Tue, 24 Jun 2008 18:25:20 GMT

I use the Windows XP Virtual CDRom Control Panel regularly. It's a great utility for mounting .iso files to a virtual cd rom drive to avoid having to burn them to an actual disk. Many large development tools (especially from MSDN) are distributed in .iso format for download. However, one of the most frustrating errors with the tool is the ambiguous "Mount Failed" exception that is sometimes thrown.

I received that error this morning while trying to mount the Visual Studio 2008 Pro image. I remembered running into this exception on numerous other occasions but couldn't remember the exact cause. After a small amount of googling and experimentation I found that my problem was caused by whitespace in the file path to the .iso I was attempting to mount.

Removing the whitespace from the file path (I just copied the .iso to the root of my C:\ drive) fixed the problem, so this time I decided to blog it in case I run into the problem again in the future.

Count > 0 vs Count != 0

Stuart Thompson — Tue, 24 Jun 2008 14:59:38 GMT

I came across an issue today that I think perfectly exhibits the principal of forward thinking in coding. Consider the following block of code:

IList<MyObject> myList = myAdapter.Read();
if (myList.Count != 0)
{
... do some work ...
}

The if statement is only executing its contents if the count of objects in the list is not zero. This seems pretty harmless on the surface. We're taking an IList<T> after all and we know that List<T>.Count returns zero if the list is empty. Therein lies the trap. We're not necessarily talking about List<T> here, we're talking about any class that implements the IList<T> interface. You can see the facepalm coming a mile away.

What if a class implements IList<T> and decides to return -1 for .Count to represent an empty collection. This is actually more common than you'd think as there seem to be a large number of people out there who still use -1 as a return code for anything that is empty or not initialized. The solution here would be to instead check for:
if (myList.Count > 0)

Instead of checking for Count != 0, we instead check if Count is greater than zero. It doesn't matter now whether the IList<T> implementation returns 0, -1, or -999 for Count to indicate an empty collection, the assertion that the if block should only run on a non-empty list still stands.

Yield - Enumeration Candy

Stuart Thompson — Tue, 24 Jun 2008 14:54:00 GMT

As we all know, I'm a little slow on the uptake. This time I managed to miss a really great keyword in C#: yield. The combination yield return is a lovely piece of C# candy that can be used to simplify a common function. Consider the following section of code:

private IEnumerable<MyObject> FindObjectsWithThreeChildren(IEnumerable<MyObject> sourceList)
{
    IList<MyObject> results = new List<MyObject>();
    foreach (MyObject obj in sourceList)
    {
        if (obj.Children.Count == 3)
            results.Add(obj);
    }
    return results;
}

We've all written something along those lines before. Build a collection up based upon some predicate and then return it. Now yes, this could actually be solved much more cleanly using a lambda expression with LINQ, but it could also be simplified using yield return. The following is the same method written to take advantage of this new keyword:

private IEnumerable<MyObject> FindObjectsWithThreeChildren(IEnumerable<MyObject> sourceList)
{
    ~~IList<MyObject> results = new List<MyObject>();~~
    foreach (MyObject obj in sourceList)
    {
        if (obj.Children.Count == 3)
            ~~results.Add(obj);~~
            yield return obj;
    }
    ~~return results;~~
}

The difference between yield return and a regular return is that with the yield keyword the method does not exit. Instead the returned result is simply added into the collection to be returned.

For obvious reasons, this can only be used for methods that return enumerations. It doesn't do anything spectacular but it does make the source code a little bit cleaner and clearer, which can only be a good thing!

Top 3 TFS Peeves

Stuart Thompson — Fri, 07 Dec 2007 18:27:56 GMT

I've been using TFS for a little over six months now and despite having its good sides, it also rears several quite ugly ones. I'm not going to harp on the obvious feature deficiencies such as branch and merge because we all know they aren't in there and that comes down to a technology choice. No, the things that really get under my skin about TFS are things that should be basic to any piece of software.

1) Check In, Lose Comments
* This is an extremely frustrating flaw in TFS for me. If you check in, but a later version of the project or file you're working on exists on the server (common in larger teams) then the project must be reloaded. After the project is reloaded, selecting CheckIn displays the exact same dialog you were in thirty seconds ago sans comments. Urrggghhh! I now always copy my comments to a clipboard or write them in textpad prior to nervously clicking the CheckIn button.

2) Updating list of changesets and work items - Please wait while we waste your time
* Does anyone else remember when a build took less than ten seconds to complete? I know that I do. If I press Ctrl+Shift+B in Visual Studio, the entire solution is built in about three seconds. If I right-click the solution and select Run Test(s) then all of the unit tests run in about thirty seconds. Why then, please educate me dear reader, does it take a full three minutes for a TFS build to do the same things!?!? Sigh.

3) Working Offline - I just need to edit this one file .... rrgghhh ... come one ... rrggh ... oh screw it!
* Perhaps in happy TFS land there is a place where internet connections are never lost and even the clouds come fitted with wireless network bridges. However, that is a far cry from where I live and work. We've all been there. You're offline, you need to make one small change and...nope...you've been sent to TFS connection jail. Enjoy your stay!

VSLive! Conference Schedule

Stuart Thompson — Mon, 29 Oct 2007 18:21:35 GMT

In all my cross-posting, I forgot to include the conference schedule indicating which classes and workshops we attended. Here it is for reference.

The following table details the schedule for the conference. I've highlighted the talks and workshops that Laura attended as well as those I attended to show our coverage of the available material.

Pre-Conference Workshops - Monday, October 15th 2007
9:00am- 6:00pm	Architecting ASP.NET Applications Paul Sheriff	SQL Server 2005: Power to the Developer Brian Randell	Making the Tough Choices: Selecting the Right Techniques for Your App Deborah Kurata
Conference Day 1 - Tuesday, October 16th 2007
9:00am	Keynote: The Trusted Platform for Your Business: Windows Server, SQL Server, and Visual Studio		D. Britton Johnston, Product Unit Manager, SQL Server, Joseph Landes, Director, Windows Server, Dave Mendlen, Director, Visual Studio
	ASP Live!		TFS Live!	.NET 3.0 Live!
10:30am	Creating a Custom ASP.NET DataSource Control Rocky Lhotka	Understanding the Update Panel Scott Cate	Managing Software Releases with Visual Studio Team System Chris Menegay	Beyond .NET 3.0: Vista and the Managed Developer Brian Randell
11:45am	What ASP.NET Developers Should Know about JavaScript Scott Allen	Building ASP.NET Database Applications with Nhibernate Benjamin Day	Customizing Team System Projects Brian Randell	Implementing SOA Design Patterns With WCF Rob Daigneau
12:45pm	Lunch
2:00pm	Using ASP.NET AJAX Extenders to Enhance Existing Sites Miguel Castro	Using Windows Workflow Foundation in ASP.NET Michiel Van Otegem	Serious Team Foundation Server Customization Benjamin Day	Windows Presentation Foundation: Making It Real Billy Hollis
3:15pm	Build a 3-tier Data Driven Website Chris Franz	Debugging MS Ajax Scott Cate	Team System Futures Chris Menegay	Windows Communication Foundation (WCF) for .ASMX and Remoting Developers Richard Hale Shaw
4:30pm	MS Ajax Under the Hood Scott Cate	Create Scalable Apps with Asynchronous Processing Michiel Van Otegem	Serious Team Foundation Server Source Control Benjamin Day	Introduction to Microsoft Windows Workflow Foundation Michael Stiefel
5:45pm- 7:30pm	Exhibitor Reception - on the exhibit floor (Brasilia)
Conference Day 2 - Wednesday, October 17th 2007
9:00am	KEYNOTE: The Microsoft Data Platform and the Data Programmer Experience		D. Britton Johnston, Product Unit Manager, Data Programmability Tools, Microsoft
	ASP Live!		TFS Live!	.NET 3.0 Live!
10:30am	Building Smart Tags & Property Builders for Your Windows or Web Controls Miguel Castro	AJAX at Scale Mark D'Urso & Allen Wagner	Making Attributes and Reflection Work for You Ken Getz	Creating Custom WCF Behaviors Rob Daigneau
11:45am	ASP.NET Master Pages - Tips, Tricks and Traps Scott Allen	Move over Flash, here comes Silverlight - Lush UI for ASP.NET Developers Walt Ritscher	How to Do a Code Review Billy Hollis	Building Custom Controls in WPF Mark Miller
12:45pm	Lunch
2:00pm	Serious ASP.NET WebPart Customization Benjamin Day	Configuration Files for ASP.NET 2.0 Robert Boedigheimer	Understanding Delegates and Events Ken Getz	Using the Windows Workflow Foundation Rules Engine as a Stand-alone Rules Engine Michael Stiefel
3:15pm	Exploiting the ASP.NET Adapter Architecture Robert Boedigheimer	Real World Exception Handling in ASP.NET Walt Ritscher	More Best Kept Secrets in .NET Deborah Kurata	WPF with Expression Interactive Designer and Visual Studio Billy Hollis
4:30pm	ASP.NET 2.0's Data Binding Features Ken Getz	IIS 7 for Web Developers Robert Boedigheimer	Best Practice Architecture: Layering Your Applications Rocky Lhotka	Best Practices for Designing and Building SOA Applications with WCF Richard Hale Shaw
Post-Conference Workshops - Thursday, October 18th 2007
9:00am- 6:00pm	Advanced C#: Moving up to LINQ, WCF and Framework 3.5 Richard Hale Shaw	Getting the Most Mileage out of Team System Benjamin Day	Build Distributed Object-oriented Apps in .NET 3.0 Rocky Lhotka

VSLive! Notes

Stuart Thompson — Thu, 18 Oct 2007 00:20:34 GMT

Disclaimer: The series of notes that I have posted from the sessions I attended at VSLive! are just that: notes. I have tried where possible to turn them into posts that have some cohesion but having attended nine hours of talks per day for four days, editing time was falling a little sparse. As I fill out these notes and write sample projects in some of the new technologies I have learned, I will update these posts accordingly. For now I wanted to get them posted and out there in a timely fashion to avoid the ideas and thoughts falling into the void. Please enjoy and use at your own risk, these notes mean a lot to me because I can pair them in my mind with the experience of the conference. Your mileage may vary.

I still have the post-conference workshop to look forward to tomorrow and will post my notes from that session as soon as I get the chance. However, I wanted to take the chance to post this disclaimer first.

Mark Miller and Rob Daigneau rock! I'm really impressed with .NET 3.0 and what the WinFX guys managed to create. I only wish that the evangelism and information sharing about those platforms had got through to me more clearly and a lot earlier. In particular, the platforms required for .NET 3.0/3.5 as well as the virtual lack of backward compatibility concerns with the 2.0 .NET framework were things that I had massive amounts of misinformation about. Sure, part of that is me not keeping up with everything as keenly as I should, but at the end of the day I found that a lot of other developers at the conference had the same misinformation. Great technology, vastly underinformed about how easily it could be applied.

Have fun and hope you've had a great week!

VSLive! Day Three - Creating Custom WCF Behaviors

Stuart Thompson — Thu, 18 Oct 2007 00:10:17 GMT

Presenter: Rob Daigneau
Code: http://www.designpatternsfor.net

I think it must either be Rob Daigneau or the topic of Windows Communication Foundation because this was yet again another superb talk. WCF was of little interest to me when I first arrived at this conference, however now I found myself extremely interested in learning more about how it might improve the architecture of my projects. It doesn't feel, like so many unfortunately do, like a technological solution in search of a problem. I can already see where I could apply WCF to bring a robust communication framework into the design of my applications.

Aspect-Oriented Programming
Aspects encapsulate the handling of a particular concern. The aspects can intercept the flow of program execution to inject their code and perform work. Custom behaviors in WCF borrow a lot of concepts from the aspect-oriented programming field of thought.

Why Custom Behaviors
There are several reasons for defining custom behaviors using interception logic:

Validate parameters and messages
Alter or Transform parameters and message
Log information about messages
Redirect operations to invoke - change the Action that is called based upon some part of the message body
Custom Error Handling
Custom Authorization

WCF Behaviors
Extensibility
The WCF runtime provides hooks for extensibility at the Sevice Model Layer and the Channel Layer.

Service Model Layer
Proxy and Dispatcher

Channel Layer
Client or Service Side

Behaviors are injected in the Service Model Layer. Extensions are added in the Channel Layer.

Framework Requirements
In order for custom behaviors to function, the .NET framework and WCF will need to be installed on the client because otherwise the .NET specific injection hooks on the client side will not function.

Interceptors
Interceptors are a means to extend the WCF runtime. The System.ServiceModel.Dispatcher contains a number of interfaces that, if implemented, can be used to define custom behaviors. By intercepting the ServiceHost.Open (on the service side) and ChannelFactory.Open (on the client side), the behaviors can be added to the WCF runtime. In this way, the flow of program execution will be intercepted at known join-points and the code within your custom behavior classes will be executed. Interceptors can also be injected at specific points on the dispatcher.

Potential Scenarios

IParameterInspector
IClientMessageFormatter
IClientMessageInspector
IDispatchMessageInspector
IDispatchOperationsSelector
IDispatchMessageFormatter

Loading the Behaviors into the WCF Runtime
In order to inject behaviors, their exist interfaces in the System.ServiceModel.Description namespace.

IServiceBehavior
IEndpointBehavior
IContractBehavior
IOperationBehavior

Scoping
Each of these is scope within the other, with the IServiceBehavior implementations having the power to inject behaviors on services, endpoints, contracts, and operations. Each tier down can inject behaviors on a smaller scope than the previous interface implementation, meaning that IOperationBehavior implementations can only inject behaviors on operations.

Means on Injection
Behaviors may be injected through configuration, attributes, or programmatic means. All behaviors can be applied programmatically. Only certain behaviors can be applied via configuration or through the use of attributes.

VSLive! Day Three - Using the Windows Workflow Rules Engine Standalone

Stuart Thompson — Thu, 18 Oct 2007 00:09:01 GMT

Presenter: Michael Stiefel

Windows Workflow Foundation contains a very powerful rules engine. However, the applications for such a rules engine do not always lend themselves to a Windows Workflow implementation. In this talk, Michael was able to show how the rules engine can used outside of the WWF framework. These notes will be updated in future posts as I work through the development of a custom wrapper and service class for abstracting the use of the rules engine.

Policy Activities
Policy activities contain rule sets. It is these rule sets that are processed when this policy activity is executed.

Rule Sets
A rule set consists of a collection of individual rules. Each rule is essentially an if...then...else construct. The then actions and else actions can modify properties and also invoke methods.

Chaining
There are three modes of chaining that can be selected for a particular rule set: Full Chaining, Sequential, or Explicit Update Only. Full chaining means that if one rule modifies a value that was used by a different rule that had already been run, the original rule can be re-evaluated taking into account the updated value.

Rule Priority
Rules have an explicit priority which is stored as a number. The higher the priority value, the higher the priority of the rule. If several rules have the same priority, they are run in alphabetical order.

Invoking the Rules Engine outside of Windows Workflow Foundation
.rules file
The rules definition file is compiled into the workflow project as a resource. Despite the fact that the rules file exists as xml on disk, replacing the file will not update the rules to be used because the WWF engine extracts the rules resource from the compiled dll at run time.

WorkflowMarkupSerializer
The WorkflowMarkupSerializer is used to deserialize an xml rules file into a RuleSet object.

RuleValidation
The RuleValidation class is used to validate a deserialized rule set to ensure that the rule set itself is valid.

RuleExecution
The RuleExecution object can be used to execute the rules against the object that will be operated upon.