Simon Brown's Blog

VMWare AddIn Crashes Visual Studio

2008-12-03T10:39:00Z

Just a note of caution to anybody out there who is installing VMWare Workstation on a PC with Visual Studio installed.

Part of the VMWare install is to add the VMDebugger add-in to Visual Studio.

On my machine I was able to open Visual Studio but as soon as I tried to open or create a new project Visual Studio would crash.

I narrowed the issue down to the VMDebugger add-in.

To rectify the issue, go to Tools | Add-in Manager in Visual Studio and uncheck the VMDebugger add-in and Startup checkboxes.

It should look like this:

I found this to be an issue in both Visual Studio 2005 and 2008.

MSDN Roadshow Re-Run

2008-11-08T23:41:00Z

I recently attended a re-run of the MSDN Roadshow at Microsoft's office in Victoria, London.

It was an overview of the latest offerings from Microsoft in the development space.

The agenda was as follows:

ADO.Next - Entity Framework and ADO.NET Data Services - Eric Nelson
ASP.Next - ASP.NET 3.5 SP1 and MVC - Mike Ormond
Silverlight V2 - Mike Taulty
Visual Studio Team Suite - Neil Kidd

The most interesting bit for me was the first session on the Entity Framework and ADO.NET Data Services. Entity Framework is an Object Relational Mapper (ORM) and Microsoft's answer to the hugely popular nHibernate. The Entity Framework still has a few quirks and is lacking in certain areas, and Microsoft seem to acknowledge this fact to their credit. It definitely seemed like a move in the right direction though with some pretty neat features.

As you would expect, Microsoft have included a wizard in Visual Studio (Entity Data Model Wizard) which you can point to a database, select the tables you're interested in, and it will generate your Entity Data Model for you. The data model consists of three different layers, each having it's own XML file and generated classes as follows:

Conceptual layer - The business entity model which is defined in an XML file using the Conceptual Schema Definition Language (CSDL)
Storage layer - A representation of the database schema which is defined in an XML file using the Store Schema Definition Language (SSDL)
Mapping layer - The mapping between the Conceptual and Storage layers which is defined in an XML file using the Mapping Schema Language (MSL)

An entity class is generated for each table in the database and also handles relationships by for example adding an Orders property (collection of Order objects) on the Customer class. Once the Entity Data Model has been generated it can then be manipulated by changing the XML files or the entity classes.

The Conceptual layer of the data model is queried by the developer using either Entity SQL (T-SQL like syntax for querying entities) or Linq (Linq for Entities). I can't imagine that anybody is going to be using Entity SQL when they can use Linq with it's expressive fluent interface. Eric recommended a tool to assist with writing Linq queries called LinqPad.

The Entity Framework also handles updates to the database including features such as Unit of Work and Identity Tracking (handling dirty data - updates which have occurred since the last database read) and Lazy Loading (this is possible, but not out-of-the-box, Eager Loading is the default mode).

I'm not sure whether Microsoft have done enough to convince nHibernate users to convert to using Entity Framework.

When Eric then went on to talk about ADO.NET Data Services that's when I started to see some real benefit to using the Entity Framework instead of nHibernate. Eric demonstrated the creation of a fully RESTful service with only a couple of lines of code. You can essentially just create a service which inherits from your Entity Data Model and "Hey Presto!" you have a RESTful service covering all CRUD operations throughout your entire data model! No need to create services anymore with methods like GetProductsById() or GetProductsByUserIdSortedByDate() or AddProduct() for each entity. This is all handled by ADO.NET Data Services. Very impressive stuff indeed!

I was even more impressed when Mike Ormond went on to talk about ASP.NET Dynamic Data. You can register your Entity Framework Data Model with Dynamic Data and a fully functional CRUD website with friendly urls is created for you using data driven page templates. RequiredFieldValidators are added for non-nullable fields, entry is limited to the number of characters the field can hold in the database, different controls are rendered based on the type of the field (e.g. check boxes for boolean values). This would be great for getting a fully functional site up and running really quickly, maybe for a prototype, or for a back end administration or simple Call Centre application.

To me this is where Microsoft really starts to excel. Their development teams seem to be working towards a common goal, with each product being built on a common framework. They develop functionality which can be utilised across their range of products. They make it easy for developers to get up and running really quickly and concentrate on delivering real business value, rather than writing boilerplate code. My only worry with this approach is that it's fine for simple applications but when things become more complex you start to hit problems. I'll have to give Microsoft the benefit of the doubt on that one as I haven't started to use any of this in anger yet!

There were some other interesting features demonstrated by Mike Ormond such as the AJAX history control, a preview of ASP.NET MVC and it's routing engine (which is also used for DynamicData), and the Silverlight ASP.NET controls <asp:Silverlight> and <asp:MediaPlayer>.

Mike Taulty discussed Silverlight 2 and Deep Zoom, and developed some Media Player Silverlight applications. He also showed us some good examples of Silverlight/Deep Zoom applications (Hard Rock Cafe, Media Toaster and Microsoft Downloads). He talked about the use of the HTMLPage and HTMLElement classes which can be used to manipulate the web page DOM from within a Silverlight application, retrieving data using limited SOAP or JSON services, and the storage of data on the client's machine using Isolated Storage.

IsolatedStorageFile.GetUserStoreForApplication();
IsolatedStorageSettings.ApplicationSettings["SettingName"];
IsolatedStorageSettings.ApplicationSettings.Save();

Neil Kidd then went on to give a demonstration of the Visual Studio Team Suite. This was mainly a demonstration of the test tools which have been around for a while now but also Database Professional (previously Data Dude) which was hugely impressive. Database Professional creates a separate file for each artifact (table, index, constraint, stored procedure etc) and contains impressive refactoring capabilities. You can change the name of a field in a table and it will automatically change the name in each of the places this is used (stored procedures, constraints etc). You can use the tool to compare the database project to an existing instance of the database and it will create update scripts for you to deploy changes. Neil also demonstrated writing database unit tests for testing stored procedures. DBA's have no excuses now! Database Professional also has an impressive tool for generating large amounts of varied test data based on rules you can specify. Very useful for performance testing. All-in-all a very nice looking product.

So, to conclude it was a very good event, with some very impressive new technology demonstrated, especially around Entity Framework, ADO.NET Data Services and ASP.NET Dynamic Data. Lots more for me to look at in my quest for continuous improvement!

Castle Windsor - Fluent Interface

2008-10-28T11:47:00Z

I attended a Skills Matter event recently on Castle Windsor. The presenters of the session were Mike Hadlow and Gojko Adzic. Slides, code samples and screencasts of the event can be found on their blogs. Mike's session was a very good introduction to dependency injection with IoC and Gojko tackled some of the more advanced features of Windsor such as facilities.

I've been using Castle Windsor for a while now on my current project favouring the use of a configuration file rather than registering components using code.

However, those of you who prefer registering your components in code will be pleased to find out that Castle have added a fluent interface to their API for Windsor. I've included an example below:

var container = new WindsorContainer();
container.Register(Component.For<ICatalogService>().ImplementedBy<MyCatalogService>().Lifestyle.Singleton);

The fluent interface is only available in the trunk version, so you'll need to download the source and compile it yourself.

I've been injecting all of my dependencies using the constructor but Mike also pointed out that Windsor also supports injecting dependencies using a property setter. This is useful if the dependency is optional. The configuration required to achieve this is the same as for constructor injection. In the following example catalogRepository is a constructor parameter and Logger is a property on the MyCatalogService class.

<container  id="MyCatalogService" 
            service="MyNamespace.ICatalogService, MyAssembly" 
            type="MyNamespace.MyCatalogService, MyAssembly">
    <parameters>
        <catalogRepository>${MyCatalogRepository}</catalogRepository>
        <Logger>${MyLogger}</Logger>
    </parameters>
</container>

Something else mentioned was Windsor's support for generics. This is something I've had to tackle recently on my own project and is especially useful for mapping classes. The following is an example of how register a class (MyProductTypeMapper) which inherits from interface IMapper<Input, Output>.

public interface IMapper<Input, Output>
{
    Output Map(Input input);
}

public class MyProductTypeMapper : IMapper<DBProductType, EntityProductType>
{
    public EntityProductType Map(DBProductType input)
    {
        ...
    }
}

<container  id="MyProductTypeMapper" 
            service="MyNamespace.IMapper`2[[MyNamespace.DBProductType, MyAssembly],[MyNamespace.EntityProductType, MyAssembly]], MyAssembly" 
            type="MyNamespace.MyProductTypeMapper, MyAssembly">
</container>

Mike also mentioned the new Common Service Locator library which is available on Codeplex. It is an abstraction around your IoC container of choice (Castle Windsor, Spring, Unity, StructureMap etc).

Also covered at the event was the use of Castle Windsor facilities. Castle provide a set of facilities out of the box including Logging, FactorySupport and NHibernate. There is also a MethodValidator facility available which allows you to add Design by Contract style functionality into your applications. An example was given using the StartableFacility which can be used to add standard functionality before and after each method call. This could be used for instance to log the entry and exit of each method. It is also possible to create custom facilities.

This is just a subset of the areas covered in the session. If you're interested in Castle Windsor then I'd urge you to watch the screencast of the session on Gojko's blog.

Continuous Improvement

2008-10-04T14:09:00Z

Sometimes in life you really come down to earth with a bump!

This is what happened to me on the first day of J.P. Boodhoo's recent Nothin But .NET bootcamp in Dusseldorf.

I like to think that I've been developing applications in the right way. I've been trying to follow good design principles, using design patterns and following best practice agile processes such as automated unit testing. Not only that, but trying to encourage others to do the same and championing some of these processes within my project. I don't think I'm the best developer in the world but I do pride myself on developing quality solutions in a professional manner. I try to keep up with new trends, tools and techniques and new language features and products.

This is however, a very fast moving industry and it doesn't take long to fall behind. This was the first lesson I learnt on day 1 of JP's course.

JP is a consummate professional. He is probably the most capable developer I have ever met. All of the course attendees were in awe of him, and these are no ordinary developers. The attendees were all very talented developers too, some of the best in Europe. JP writes code at the speed of light, having complete command of the keyboard (he never uses a mouse). In fact it seems that the only thing that's slowing him down is the speed of the virtual machine which is struggling to keep up with the ferocious battering of the keyboard. This is not only due to the fact that JP is fast at typing but more due to the fact that he has configured his development environment for optimum performance, using any tools at his disposal and learning every aspect of them. Resharper is his main tool of choice, as it is for many of us, but JP knows it inside out. He has an encyclopedic knowledge of keyboard shortcuts, it's a joy to watch.

Not only is he fast but the quality and design of the code is very high. JP is very well read and has extensive knowledge of design patterns and OO design principles, but the impressive bit is that he knows exactly when to use them. In the past I've worked with developers who have learnt a new pattern and then decided to use it everywhere like it's a silver bullet. Not so with JP. So what do we end up with? A very well designed application. Small classes containing small methods adhering to the Single Responsibility and Open Closed principles amongst others.

The way JP works is also very efficient. He takes a top down approach to development, starting with the UI, working down to the domain layer, introducing stubs as early as possible. Taking this approach the client gets very early visibility to the UI and is able to see if it works for them. Let's face it, a lot of the time the UI is the main part of the application that the client is interested in, so it makes sense to get this to them as early as possible. And let me be clear here, we're not talking about a prototype UI, but production quality code. Once the UI is finished, we can then move on to the Service and Domain layers. Taking a top down approach also stops you from over engineering a solution and being too reliant on underlying legacy data structures.

JP is also a vociferous proponent of Test Driven Design, or more specifically Behaviour Driven Design. Not only does he "talk the talk" but he also "walks the walk". JP never writes a line of production code without first writing a failing test, no excuses. In the past I’ve worked with developers who are very resistant to concepts such as TDD and good design principles, always having an excuse for not doing it (haven’t got enough time, the managers/clients aren’t interested etc.). This is not the case with JP. The tests are written using human readable English and fluent interfaces and constructed using interfaces and mocks meaning even the least technical of us can understand the functionality of the code we are testing. Writing the tests in this way helps to flesh out the design.

By now you're probably thinking that JP's bootcamp course is some kind of a cult, and this is the start of a big recruitment drive! Well, you'd be wrong. In fact one of the things that JP discourages is putting people on a pedestal. It's not healthy and it holds you back. Everybody has something to offer and improvements can always be made.

I learnt an awful lot about C#, OO Design, patterns, and best practice development on the course, and got to spend the week with a fantastic group of talented developers. However, the main thing I've learnt is that you can't rest on you laurels or past glories in this industry. Every single one of us can improve. We'll never know everything, we may never be a big shot in the industry, but that shouldn't stop us putting in the effort to improve ourselves.

Attending JP's course was like a big kick up the backside for me. That's enough talking for now. I'm wasting valuable study time!

For a more detailed and humorous account of JP's Dusseldorf course, checkout Michel Grootjans blog at http://geekswithblogs.net/alternativedotnet.

Talking of humour, I said I'd dedicate my first blog post to my good friend Ciaran Roarty, a fellow developer and the hottest new act on the Glasgow comedy scene! Check out his blog at http://www.ciaranroarty.com.