Richie's World

Deploying a VSTO Click Once Add-in - don't forget your MIME Types!

noreply@blogger.com (Richard Allen) — Mon, 07 Nov 2011 16:24:00 +0000

I just wanted to make a note of this for future reference and to help any one that might be struggling with this in the future:

I have just created a simple Excel 2007 office add-in and I wanted to deploy it to a local server on my intranet and allow other users to click a url and install the application. Using the project properties page I configured the relevant server details and successfully published the add-on on to the server.

But when I navigated to the specified install url I received 403 error This website requires you to login. After searching the web for a suitable answer I finally stumbled upon the answer on this web site:

http://social.msdn.microsoft.com/Forums/en-MY/winformssetup/thread/10ee1ca1-b3ae-4a6f-98ba-125179b9e417

In summary, don't forget to configure the .'vsto' MIME type with 'application/x-ms-vsto' on the virtual directory containing the add-in.

CodeKen - the replacement conference for StackOverflow DevDays

noreply@blogger.com (Richard Allen) — Wed, 05 Oct 2011 07:16:00 +0000

CodeKen London 2011 is a brand new developer conference delivering two days of hands-on coding oriented content over the 14 - 15th November in London. The event was organised in response to the cancellation of the Stackoverflow DevDays conferences and includes many of the original speakers like Jon Skeet, Robert Pickering and Richard Marr.

The talks cover a wide range of subjects including programming style, MongoDB, NodeJS, HTML5, REST services and more.

In addition to an eclectic mix of talks CodeKen 2011 is launching a developer side project competition. The goal is to encourage and publicise developers that are spending their spare time working on interesting projects. Five finalists will be given a free ticket to the conference and a chance to present their project at the event.

See the full conference schedule and more information on the CodeKen Side Project competition on the conference site - http://london2011.codeken.com

NxtGenUG Fest 10 - “Beside the C# side” – Bournemouth 16th July

noreply@blogger.com (Richard Allen) — Mon, 05 Jul 2010 23:06:00 +0000

NxtGenUG are pleased to announce their annual conference Fest10 will be taking place on Bournemouth Pier this year on Friday the 16^th July 2010 – It’s a great opportunity to take the family to the Seaside for the weekend, and catch up on technology. The best thing is attendance to the conference is free to members and just £59.95 for non-members.

Speakers

We have a great speaker line up this year, Google’s Jon Skeet will be talking about C#, Microsoft’s Glenn Block is coming over from Redmond to talk about MEF, Ryan Simpson will be giving us the lowdown on F#. We’ll also be having NxtGenUG veterans Mike Taulty, on OData and Chris Hay on Azure, Plus Marcus Perryman will be talking about one of the hottest technologies this year Windows Phone 7.

You can find a list of speakers and their sessions here

http://www.nxtgenug.net/fest10/Sessions.aspx

To register simply go to the following link and follow the instructions on screen.

http://www.nxtgenug.net/fest10

Parking, Hotels and Timings

Upto date Details on parking, hotel accommodation and timings for the day can be found on the Fest10 site. The nearest parking for Bournemouth Pier is either in the Bournemouth International Centre (BIC - 20) car park, the Bournemouth Pavilion car parks (19/24) or the car park next to the Royal Bath hotel (18). However, there is also further car parking available at Eden Glen car park (21), Winter Gardens car park (22) and Beacon Road car park (25). For Hotels, the RusselCourt is where the evening entertainment will be Quote: NxtGenUG when booking, otherwise Bournemouth has a large amount of hotels, including the Best Western Hotel Royale.

http://www.nxtgenug.net/fest10/

Geek Dinner

It's the Fest10 geek dinner - normal rules apply - pay for your own food/drink, and engage in great conversation, and eat fish and chips at Harry Ramsden’s. To register for the geek dinner

http://www.nxtgenug.net/ViewEvent.aspx?EventID=322

Post Fest Party

We’ll also be having a post Fest Party at the RusselCourt Hotel – If you’ve brought your family down for the weekend feel free to bring them along. Just register on the site and drop us an email on how many people you’ll be bringing with you toenquiries@nxtgenug.net

http://www.nxtgenug.net/ViewEvent.aspx?EventID=325

Sponsorship

NxtGenUG would like to thank DevExpress, our gold sponsor, along with Microsoft, RedGate, PluralSight and Apress for their support in making this event possible.

CSM course in Bournemouth 23 & 24 November

noreply@blogger.com (Richard Allen) — Mon, 02 Nov 2009 20:17:00 +0000

Geoff Watts will be holding a CSM training course in Bournemouth on the 23/11/2009 and 24/11/2009. For full details see here

An ASP .NET Testing Time Ahead

noreply@blogger.com (Richard Allen) — Mon, 17 Aug 2009 21:50:00 +0000

Thursday 20th August sees NxtGenUG Southampton hosting a web application testing session that is not to be missed. Testing guru and general all round community good guy Ben Hall is coming down to pay us a visit and talk about all things web test, Ben will be looking at how you can test different aspects of ASP .NET from the core engine to the UI and databases. Topics will include test driven development, mocking of external services as well as UI automation but probably most importantly Ben will be describing the best way to get started with testing you web application.

All in all this looks like a great session and if you are in the area I would definitely recommend paying us a visit.

Unit Testing ASP.NET? ASP.NET unit testing has never been this easy.

noreply@blogger.com (Richard Allen) — Wed, 20 May 2009 19:38:00 +0000

Typemock is launching a new product for ASP.NET developers – the ASP.NET Bundle - and for the launch will be giving out FREE licenses to bloggers and their readers.

The ASP.NET Bundle is the ultimate ASP.NET unit testing solution, and offers both Typemock Isolator, a unit test tool and Ivonna, the Isolator add-on for ASP.NET unit testing, for a bargain price.
Typemock Isolator is a leading .NET unit testing tool (C# and VB.NET) for many ‘hard to test’ technologies such as SharePoint, ASP.NET, MVC, WCF, WPF, Silverlight and more. Note that for unit testing Silverlight there is an open source Isolator add-on called SilverUnit.

The first 60 bloggers who will blog this text in their blog and tell us about it, will get a Free Isolator ASP.NET Bundle license (Typemock Isolator + Ivonna). If you post this in an ASP.NET dedicated blog, you'll get a license automatically (even if more than 60 submit) during the first week of this announcement.

Also 8 bloggers will get an additional 2 licenses (each) to give away to their readers / friends.
Go ahead, click the following link for more information on how to get your free license.

Using Linq to SQL to validate Data Access Logic

noreply@blogger.com (Richard Allen) — Wed, 29 Apr 2009 15:36:00 +0000

So Microsoft aren't going to be supporting Linq to SQL (L2S) see "Microsoft Kills Linq to SQL" for more info, but there are still some great situations that it can be really useful in your environment with it going into a production build and one of those is using L2S for testing your data access logic.

This post aims to talk you through a way of using L2S to confirm that what you think your data access logic is doing is what your data access logic is actually doing.

A really useful tool that comes with L2S is called SQLMetal, this tool is used to automatically generate a data context based on the current schema of a given database. So instead of using the fancy designer front end, you auto generate the whole database schema including Stored Procedures and Views if you want but you can restrict this if you want by simply not including the required input parameter. To do this every time your application builds simply amend your project file with the following ensuring that you replace the text in [] with your specific fields:

<Target Name="BeforeBuild">
    <Exec Command="&quot;C:\Program Files\Microsoft SDKs\Windows\v6.0A\bin\SqlMetal.exe&quot;  /server:[ServerName] /Database:[DatabaseName] /code:[MyDataContext].cs /context:[MyDataContext] /namespace:[MyCompany].[MyProject].DataAccess /views /sprocs /functions /pluralize  WorkingDirectory="$(ProjectDir)" />
</Target>

The parameters /views /sprocs /functions will expose all of the views, stored procedures and functions accordingly. The /pluralize parameter indicates that you want to generate plural names for tables so a table called "Customer" will be exposed as "Customers" in the data context. For full details of the parameter list go here. Once you've modified the project file reload it and when you next build the project file it will generate a data context for you with as much of your database exposed as you would like.

So now that we have our data context we can put this to good effect when testing our database access logic, for example take the following data portal insert method from a CSLA business object which will be called when our business object is new and the Save method is called:

protected override void DataPortal_Insert()
{
    using (var connection = ConnectionManager<SqlConnection>.GetManager("MyDatabase").Connection)
    {
        SqlCommand cmd = new SqlCommand();
        cmd.CommandType = CommandType.StoredProcedure;
        cmd.Connection = connection;
        cmd.CommandText = "usp_CreateEmployee";
        cmd.Parameters.AddWithValue("@FirstName", ReadProperty(FirstNameProperty));
        cmd.Parameters.AddWithValue("@LastName", ReadProperty(LastNameProperty));
        cmd.Parameters.AddWithValue("@EmailAddress", ReadProperty(EmailAddressProperty));
        cmd.ExecuteNonQuery();
    }
}

This method quite simply executes a stored procedure called "usp_CreateEmployee" and passes in the parameters from the business object. What we want to do here is validate that the parameters are correctly passed from our business object into our stored procedure and the stored procedure correctly performs an operation to insert a new employee with the details set on the business object. What we don't want to do here is have to write a whole bunch of code in order to do this, step in L2S.

So now back in our unit test we can do the following:

        [TestMethod]
        public void EmployeeIsCreatedInDatabase()
        {
            TestDataContext = new MyTestDataContext(CreateConnection());

            int initialCount = TestDataContext.Employees.Count();

            const string FirstName = "TestFirstName";
            const string LastName = "TestLastName";
            const string EmailAddress = "test@test.com";

            // Create business object and set values
            var employee = Employee.NewEmployee(CompanyId);
            employee.FirstName = FirstName;
            employee.LastName = LastName;
            employee.EmailAddress = EmailAddress;

            // Call save on business object, this will execute data portal logic 
            // and insert a new row in the database with the new values
            employee.Save();

            // Refresh our data context with data from the database
            TestDataContext.Refresh(RefreshMode.OverwriteCurrentValues);

            // Now get the new employee table count and assert it has increased by 1
            int newCount = TestDataContext.Employees.Count();
            Assert.AreEqual(initialCount + 1, newCount);

            // Now get a Linq Employee object directly from the data context and verify that
            // the all of the fields have been populated as we expected them to.
            LinqEmployee linqEmployee = TestDataContext.Employees.OrderByDescending(e => e.ID).FirstOrDefault();
            Assert.IsNotNull(linqEmployee);
            Assert.AreEqual(linqEmployee.FirstName, FirstName, "Expected first names to match");
            Assert.AreEqual(linqEmployee.LastName, LastName, "Expected last names to match");
            Assert.AreEqual(linqEmployee.Email, EmailAddress, "Expected email addresses to match");
        }

As you can see from the above code, the test creates a TestDataContext L2S object and takes an initial count of the number of employees in the Employee table and defines our test values as constants.

Next we create a new employee business object and set the appropriate values with the test data. We then call the Save method on the business object, this is the method we are actually testing and we want to ensure that it correctly passes the information set on the business object down to our data access layer and then the data access layer inserts the appropriate data into the relevant tables.

We can then verify that the Save method has done what it needed to do by using out TestDataContext, we simply refresh the data with values from the database and then perform some assertions. Firstly, we check that the employee count has incremented by 1, this ensures that an insert was performed on the table. Next, we sort the employees by Id and order descending ensuring that we get the latest Id generated by the table - our new employee should be the last row in the table (unfortunately the Last() function in L2S does not work so we have to do this order by descending approach). We then get an instance of this L2S object and perform assertions on its properties ensuring that the data we set on our business object has been set on the L2S object.

Conclusion

Linq to SQL may no longer be supported by Microsoft and as such might not be suitable for production ready systems, but it can still be a really useful tool especially when performing data tests to ensure our data access layers are performing as we expect. I hope you find this post useful and it helps you to get a bit more data access testing done. Let me know your comments.

Unit Testing CSLA with Type Mock Isolator

noreply@blogger.com (Richard Allen) — Tue, 28 Apr 2009 14:51:00 +0000

I am a huge fan of CSLA and look to try and use it in projects where ever I can as it just makes life so much simpler by taking some of the major decision points out of the development cycle allowing you to focus on the real problem which is defining and designing your business logic layer for what ever project you are working on.

As with any framework, CSLA has its benefits and it has its drawbacks, I am not going to go into all these in this post as there are plenty of people that have already had these discussions already but one of the major drawbacks I found was when trying to unit test my CSLA objects.

In a nutshell your CSLA based business objects inherit from a base class called BusinessBase<T>, this class implements a whole bunch of useful features such as authorisation rule checking, validation rule checking, n-level undo, distributed business objects via the data portal etc that can be utilised by any inheriting class.

Probably the key area is the Data Portal mechanism which performs the following (please note this is over simplified for clarity) when the Save() method is called on your business class:

Determine the state of your class, is it Valid (all data is correct) and Dirty (some data has changed)
Determine what kind of operation to perform (If the object is new then Insert else Update etc)
Serializing your business object
Transport the business object to your data access layer (which could be across a server boundary)
De-serializing the business object
Executing any required data access logic i.e. Insert, Update, Fetch operations
Perform any validation rules required
Serialize the object again
Transport the business object back to the application layer (which could be across a server boundary)
De-serializing the business object
Return a new instance of the application logic

As you can see CSLA does a lot of work under the hood which involves a lot (and I do mean a lot) of reflection which is all good for making your life as a developer great when developing the business domain but this becomes a problem when coming to unit test and mock out parts of the system.

CSLA encapsulates the data access logic methods i.e. DataPortal_XYZ within the business object, which is probably its most controversial point, but this does not restrict your choice of the actual data access mechanism that you want to use, I personally am using Linq to SQL as my data access layer and find that it is extremely quick and easy to:

Add new columns to the database
Expose them via Linq to SQL
Expose them in the business object
Add any validation rules in the business object
Put a field on the UI

That said, any other type of data access could easily used instead such as Linq to Entities, NHibernate, ADO .NET etc etc.

So hopefully you are starting to see the problem we might have with unit testing, essentially as soon as you perform an action on an object such as set a property, CLSA will perform some behind the scenes work to execute authorisation and validation rules to determine whether the current user is permitted to perform the action and then determine whether the property is valid after its value has been set. It is this "behind the scenes" work that is absolutely awesome and makes CSLA a great framework but makes the mocking and unit testing almost impossible as it becomes very difficult to isolate the various parts of the business object.

I have been working Rhino Mocks for a while and found that this has been great especially when compared to NMock but when I tried mocking a CSLA object it let me down. It seems that the problem is that Rhino Mocks relies on Dependency Injection to perform its mocking and because CSLA objects are generally closed and do not expose ways of injecting mocks into the objects it is impossible to replace the data access logic with a mock replacement - or so I thought until I came across TypeMock.

TypeMock Isolater uses Aspect Oriented Programming to create a mock aspect, it essentially monitors the applications execution and registers an interest in specific methods on an object with the .NET framework API, when the method is called the .NET framework notifies the TypeMock and allows it to return mocked objects or values. What this means is that we don't need to change our objects and sacrifice our "good OO design" in order to perform unit testing of our objects.

Here is a very simple example of how I have used Type Mock to fake a couple of child objects that exist on my Employee class, I want to test the validation rules on the Employee object but I do not want to have to load or create a new instance of either Workgroup or Role properties so I simply create a "fake" instance using the Isolate class:

        private Employee CreateEmployee()
        {
            var employee = Employee.NewEmployee(CompanyId);
            employee.FirstName = "Test";
            employee.LastName = "Employee";
            employee.EmailAddress = "test.employee@testcompany.com";
            employee.Workgroup = Isolate.Fake.Instance<Workgroup>();
            employee.Role = Isolate.Fake.Instance<Role>();
            return employee;
        }

Now my Employee class has all of its properties set (two of them with fake objects) and therefore will be valid, I can independently test each validation rule to ensure that they are fired correctly when the relevant property on the object changes, in the following case I ensure that the "Email address is required" rule is fired:

        [TestMethod]
        public void EmailAddressIsRequired()
        {
            var employee = CreateEmployee();
            employee.EmailAddress = null;

            Assert.AreEqual(1, employee.BrokenRulesCollection.Count());
            Assert.IsTrue(employee.BrokenRulesCollection[0].Property == "EmailAddress");
            Assert.IsFalse(employee.IsValid);
        }

Now admittedly I could have achieved the same thing here using Rhino Mocks and creating a mock instance of each of the classes, but lets say for example the Employee object has a custom validation method that using a command object to determine whether an employee with the same email address already exists, the command object might look something like this:

        class EmployeeExistsCommand : CommandBase
        {
            public bool EmployeeExists { get; set; }
            public string EmailAddress { get; set; }

            private EmployeeExistsCommand(string emailAddress)
            {
                EmailAddress = emailAddress;
            }

            public static bool CheckIfEmployeeExists(string emailAddress)
            {
                var cmd = new EmployeeExistsCommand(emailAddress);
                cmd = DataPortal.Execute(cmd);
                return cmd.EmployeeExists;
            }

            protected override void DataPortal_Execute()
            {
                using (var ctx = Csla.Data.ContextManager<HolidayPlanrDataContext>.GetManager(HolidayPlanr.DataAccess.Database.HolidayPlanrDb))
                {
                    var data = from e in ctx.DataContext.Employees
                               where e.Email == EmailAddress
                               select e;

                    EmployeeExists = data.SingleOrDefault() != null;
                }
            }
        }

The main thing to note here is that this command makes a trip to the database via Linq to SQL in order to determine whether an employee with the same email address already exists. If we add a custom validation rule to our Employee class to execute this command like so...

protected override void AddBusinessRules()
{
    ValidationRules.AddRule(CommonRules.StringRequired, FirstNameProperty);
    ValidationRules.AddRule(CommonRules.StringRequired, LastNameProperty);
    ValidationRules.AddRule(CommonRules.RegExMatch, new CommonRules.RegExRuleArgs(EmailAddressProperty, @"\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*"));
    ValidationRules.AddRule(Rules.ObjectRequired, FirstNameProperty);
    ValidationRules.AddRule(Rules.ObjectRequired, LastNameProperty);
    ValidationRules.AddRule(Rules.ObjectRequired, EmailAddressProperty);
    ValidationRules.AddRule(Rules.ObjectRequired, RoleProperty);
    ValidationRules.AddRule(Rules.ObjectRequired, WorkgroupProperty);
    ValidationRules.AddRule(EmployeeAlreadyExists, EmailAddressProperty);
}

And the static method that implements the logic looks like this:

        private static bool EmployeeAlreadyExists(object target, RuleArgs args)
        {
            if (target is Employee)
            {
                var employee = target as Employee;
                if (employee.IsNew)
                {
                    if (EmployeeExistsCommand.CheckIfEmployeeExists(employee.EmailAddress))
                    {
                        args.Description = string.Format("An employee already exists with email address {0}", employee.EmailAddress);
                        return false;
                    }
                }
            }
            return true;
        }

Now when we run our unit tests the creation of our Employee object will execute the validation rules and therefore call the static method and make a call to the database to determine whether the employee already exists which is what we don't want to happen because now this rule will fire for all of my other tests.

This is, as I see it, where the power of Type Mock Isolator comes in, what I can do now is define an Isolate command to intercept any calls to the EmployeeAlreadyExists method and simply return the validation result I want. So I can do this by declaring the following in my CreateEmployee method:

private Employee CreateEmployee()
{
    Isolate.NonPublic.WhenCalled(typeof(Employee), "EmployeeAlreadyExists").WillReturn(true);
    
    var employee = Employee.NewEmployee(CompanyId);
    employee.FirstName = "Test";
    employee.LastName = "Employee";
    employee.EmailAddress = "test.employee@testcompany.com";
    employee.Workgroup = Isolate.Fake.Instance<Workgroup>(Members.CallOriginal);
    employee.Role = Isolate.Fake.Instance<Role>(Members.CallOriginal);

    Isolate.Verify.NonPublic.WasCalled(typeof (Employee), "EmployeeAlreadyExists");

    return employee;
}

So now prior to creating a new instance of the Employee object I define an isolation of a non-public method called "EmployeeAlreadyExists" on the class Employee and set its return value to "true" ensuring that by default this validation rule will always be true allowing me to continue and isolate my other validation rules.

The second statement I added was just a verify statement which ensures that a call was actually made to the "EmployeeAlreadyExists" command, so this lets me know if there was a problem in the actual call to the method.

Conclusion

Type Mock Isolator allows areas of a system that were previously un-testable/mockable to now be tested and mocked in a nice and easy to understand way, I like it very much because it now gives me the ability to write some much more in depth CSLA unit tests without breaking my OO design.

It is very powerful and could easily be mis-used or over-used but with benefits of increasing general unit test coverage it is probably worth it.

One major drawback is the lack of a community edition, the product comes with a 21 day enterprise license that reverts to the free features after the trial period. The single user license priced at 89 euros which I suppose could be well worth the price considering the peace of mind that could be achieved after unit testing those hard to reach places - all in all I like it and would recommend others at least give it a try.

UK South Scrum User Group (UKSSUG)

noreply@blogger.com (Richard Allen) — Tue, 28 Apr 2009 07:08:00 +0000

It's been a while since I last blogged, can't really think of a decent reason apart this thing called Twitter taking up a fair bit of time recently, I've not been twittering myself all that much but doing lots of reading of tweeple's tweets in the twittersphere.

Anyway, with that out of the way, last night I went to the second meeting of the UK South Scrum User Group to talk about "The Definition of Done", something that seems to plaque the majority of people developing software.

It was a great evening lead by Mike Williams, we discussed the various stages of "done" including Tasks, User Stories, Iterations and Releases and everybody suggested ways in which it is possible to define "done" and talked about ways in which any problems we were facing could be addressed.

All in all a great second night of the user group, its great to be apart of a group that I am not running so that I can actually participate rather than constantly trying to organise the next thing for NxtGenUG. If you fancy coming along to UKSSUG, it's an open invite and totally free, keep an eye on the linked in group and we'll get the next meeting date posted up soon.

New South Coast Scrum User Group

noreply@blogger.com (Richard Allen) — Tue, 31 Mar 2009 12:47:00 +0000

The South Coast now has a new user group for all those interested in Scrum and anything Agile. Plamen Balkanski and a couple of other Agile enthusiasts have setup this user group to help spread the word of Scrum within the local area, anyone is welcome whether you are new to Agile or an experienced Scrum Master.

The next session will be on 27th April and the topic is "Getting acceptable definition of done" - which seems to be a bit of a classic Agile development issue.

The meeting starts at 19:00 and will continue until 21:00 and can be found at:

The Inn on the Furlong
Meeting House Lane
Ringwood
Hampshire
BH24 1EY

http://www.ringwoodbrewery.co.uk/iof.htm

To register for the event go to: http://ukssug.eventbrite.com , it's free but this is necessary so we know how many people are going to attend. You can also join the LinkedIn group here, where you will find discussions, notes and links with details from previous meetings.

Look forward to seeing you there.

I am on Twitter

noreply@blogger.com (Richard Allen) — Fri, 06 Feb 2009 12:07:00 +0000

For anyone interested, I am now on Twitter: http://www.twitter.com/rich_allen.

Subtle changes to Tortoise SVN increase machine performance

noreply@blogger.com (Richard Allen) — Fri, 06 Feb 2009 11:59:00 +0000

For the last I don't know how long, I've been complaining about the speed of my work desktop machine. It's a dual-core with 2GB RAM running XP but it runs like an absolute pig. A colleague of mine recently did some digging and found that unless you make some subtle changes to Tortoise SVN it does quite a bit of unnecessary work in the background.

Quote from colleague:

"I think a significant factor in our machines being slow is Tortoise performance as it is monitoring and caching all file modifications (it is the biggest user of CPU time on my box).

This article makes some recommendations - http://tortoisesvn.net/node/267.

I’ve followed a couple and it seems to have made some difference:

1. Right Click->Tortoise->Settings – Icon Overlays Tab

Add excludes to all drives.

Add an include to your working directory only.

2. Remove all currently unused source directories - > I have removed the branches etc and only have MF and MIS trunk checked out for instance."

Also, doing the following can help if you don't mind losing the pretty overlay icons on some of your files:

Select status cache = none.

This means you lose having meaningful icons on the your source folders, but the rest of tortoise works – commit/update/get modifications etc.

I can live without the icons….

Since making these changes I have seen a marked difference in how my machine responds...hooray!

BHF - Bournemouth Bay 10K Run 2009

noreply@blogger.com (Richard Allen) — Thu, 08 Jan 2009 11:22:00 +0000

Now I am a little confused as to how I have actually got myself into this but in the whirl wind return to work after a great Christmas and New Year, a colleague at Fitness First decided to send a link around and say that he was taking part in the Bournemouth Bay 10K Run for the British Heart Foundation.

Before I knew it a couple of other colleagues had signed up to it and I compulsively found myself stating something like "...yeah sounds good to me, where to I sign...". So I am firmly signed up to this huge challenge (I am a software developer not a road runner by any means) and so the training has started and the plea for aid and donations has begun.

I've not really done anything like this before but if anybody is interested in helping me raise money for the British Heart Foundation or simply wants to be bet that I cannot do it (should encourage me some more), then please feel free to pop along to My Fundraising Page or use the widget in the side bar and donate as much as you can afford.

Many thanks

The Tricky Design Experience with Dr. Neil Roodyn

noreply@blogger.com (Richard Allen) — Thu, 08 Jan 2009 10:13:00 +0000

Next week on Thursday January 15th we've got Tricky Basset coming to show us the 'Tricky Design Experience' at NxtGenUG Southampton. After seeing Bill Buxton's key note at Remix '08 it became clear that Microsoft is really moving into this design space with some considerable vigour, the concept of people not buying products but buying experiences is something that Microsoft seem to have missed over the years whereas companies like Apple have seemed to excel.

Tricky will talking us through his team's iterative approach to design including Branding, Ideation, Research, Sketching and Conceptualisation and showing off some great WPF and Silverlight projects.

As a special treat Tricky has invited Dr. Neil Roodyn (MVP) to travel all the way from the land of Oz to join him for this exclusive session at NxtGenUG Southampton, together they shall be providing an interactive session with lots of audience interaction.

Design is something that I've always wanted to get a grip on (in that I have no design skills whatsoever) and I personally can't wait for this session it is stacking up to be an awesome experience and one not to be missed.

See you there!

Awesome WPF Data Binding Session

noreply@blogger.com (Richard Allen) — Fri, 12 Dec 2008 11:25:00 +0000

Last night saw a great session at NxtGenUG Southampton with Josh Twist showing us his WPF data binding and Expression Blend skills. It was the second time I've seen him do this session and its still great.

For anyone interested Josh's blog is: http://www.thejoyofcode.com

Lets Twist Again

noreply@blogger.com (Richard Allen) — Wed, 10 Dec 2008 13:50:00 +0000

If anybody attended Fest '08 this year and you managed to see Josh Twist perform his WPF and data binding magic then you will know that this guy is an excellent speaker who delivers a fun packed informative session that certainly left me thinking "wow...so that is how you are supposed to use all of this Expression Blend stuff".

Well tomorrow sees the return of the Twist to NxtGenUG but this time we have the pleasure of his company down on the south coast in the Southampton region, Josh will be giving us a WPF and data binding refresher with some new stuff for those that managed to catch the Fest 08 session.

Of course there will be the usual pizza and swag and hey as it's the festive may be there will some merriment of some kind.

Hope to see you there

SQL Server 2008 with Eric Nelson

noreply@blogger.com (Richard Allen) — Mon, 24 Nov 2008 20:54:00 +0000

It feels like it's been forever since the last NxtGenUG meeting but as luck would have it this Thursday sees November's instalment. We've got Microsoft Evangelist Eric Nelson coming down to pay us a visit and give a detailed discussion on the new features of SQL Server 2008 that we all might find a little useful.

There will be the usual pizza and of course swag (which may include some SQL Server Standard licenses) if you are lucky.

For more information check it out here and don't forget to register.

Another Cracking Session

noreply@blogger.com (Richard Allen) — Tue, 21 Oct 2008 08:27:00 +0000

Last Thursday 16th October saw another great session at NxtGenUG Southampton, Plamen Balkanski and myself discussed Scrum and Agile techniques and end the session with a planning game that was based around a NxtGen pizza machine.

Everyone was split into groups of 5 people and given two iterations of 10 minutes to produce drawings/models of the end product, the whole point of the game is to give people a very brief introduction into what it might feel like to be on an agile team. The response we had from most members was generally positive and they all had fun although some people were a little confused and didn't quite get it.

If any one is interested in the slides they can be found here.

"Agile" Birthday to Us

noreply@blogger.com (Richard Allen) — Thu, 09 Oct 2008 22:11:00 +0000

So my run of presenting seems to be continuing what with my WatiN nuggets at NxtGenUG Southampton, followed by my WatiN nugget success at Remix 08 and then a recent WatiN nugget at NxtGenUG Cambridge I figured it was may be time for a change. So I am teaming up with a good friend of mine Plamen Balkanski to do a full session on Scrum and Agile methods at NxtGenUG Southampton, it's also the Southampton region's 1st birthday so it should be quite fun with the usual pizza and swag a plenty.

The session will essentially be an introduction to Scrum, what is it all about and why your company may benefit from using it, but we'll also be getting everyone involved in an agile planning game that will ensure that every single attendee will "feel" what it is like to be involved in an Agile project when it is done correctly.

The session is taking place on Thursday 16th October and you can find more details about it here, I look forward to seeing you there.

WatiNCF - Live on CodePlex

noreply@blogger.com (Richard Allen) — Thu, 09 Oct 2008 21:44:00 +0000

I've had a fair bit of interest in my WatiN Controller Framework recently and after attending Remix the other week and seeing Sara Ford (her blog has some awesome Visual Studio tips and tricks) doing a talk about CodePlex and it's new integration with Subversion clients such as Tortoise SVN I decided it was about time I published it, so for anybody that may be interested, the project can be found at http://www.codeplex.com/WatiNCF.

At the moment there aren't any help files apart from my blog and there is no installation file so you'll just have to download the source code and build it for yourself, if I get a bit of time over the coming weeks I'll post a bit more about how you go about using the framework but if you have any immediate questions in the short term just let me know.

Please feel free to add any comments or submit proposals for changes or even contribute to the project if you like, just let me know how you get on with it if it helps you or even if it doesn't.

I hope you find this useful in some way.

Rhinos Stampeding Bristol User Group

noreply@blogger.com (Richard Allen) — Tue, 30 Sep 2008 10:27:00 +0000

People in the community are generally quite a friendly bunch but now and again the green eyed monster can creep up on you when you find that a fellow user group has managed to get an absolutely great speaker and this one is no exception.

Our good friend Guy Smith-Ferrier has managed to secure a session with Oren Eini (aka Ayende Rahien), the founder of Rhino Mocks and major contributor to Castle and NHibernate, over at the .NET Developer Network in Bristol. This has come at relatively short notice as Oren is only around for the next couple of weeks. The event takes place on Monday 13th October, more details can be found here.

The session details are as follows:

"Producing Production Quality Software" Abstract:

Working software is no longer the only thing that we need to produce. We need to create a software system that has a chance of surviving in the cruel world of production system, outside the clean room and sterile environment of development and QA. Understanding bottlenecks in the system, preventing cascading failures and recovery strategies have ceased being the problems of the very high end players. With the cost of system downtime being measures in $$$/second, this is an area we have to consider all the way. In this talk we will cover how we can map common weaknesses in the system design, preemptively protect ourselves from them, and produce software systems that can withstand the real world hostile environment.

"Interaction based testing with Rhino Mocks" Abstract:

Beyond the simplest scenarios, all objects had collaborators that they work with. This flies in the face of testing objects in isolation. This is the problem that mock objects were created to solve. In this talk you will learn what mock objects are, how to utilize them and best practices on when / how to utilize them. Rhino Mocks is a mock objects framework for .Net whose core goals are to let the developer rely on the compiler work well with refactoring tools.

Seriously, if you want to hear from a person whom many consider a legend in our industry and you can make it to Bristol on that day, this would be one not to miss!

Remix '08 and Ready, Steady, Speak Success

noreply@blogger.com (Richard Allen) — Sun, 21 Sep 2008 19:36:00 +0000

I've spent Thursday and Friday at Remix '08 and I must say I had a great time, from the key note by Bill Buxton and Scott Guthrie to the excellent Swag Phrase events at the community stage during the intervals it was a excellent couple of days that were well worth attending.

Admittedly I had already learned a lot about some of the developer talks that were taking place by attending other community events I had attended over the year so I took the opportunity to go to a couple of the design flavoured talks by Bill Buxton and I must say it was well worth it, design certainly is not my strong point and anything I can do to try and improve my understanding of how it should be applied cannot be a bad thing, I managed to pick up of few key points about not trying to design the perfect product in one go and some cheeky little prototyping tricks such as using magnets to mimic working screen shots.

Certainly my highlight of the event was the Ready, Steady, Speak competition. It was my first opportunity to talk to about my chosen subject to a large number of people at a major UK event, I've done a couple of nuggets at NxtGenUG - Southampton from time to time but nothing on this kind of scale. My chosen topic was WatiN and arriving at Remix I was happy with the presentation I had put together. There were six competitors in total taking part in two heats on the Thursday with the top two going through to a final session on the Friday, topics from other competitors included ASP .NET MVC, OAuth, HSL (Hue/Saturation/Luminance), Rasta and using Silverlight to perform cross browser window communication.

In the first heats I was last on which gave me an opportunity to see all of the competition but also for the nerves to build up, and up and up :-). There were four panel judges who passed judgement on each of the presentations and gave some useful comments on how the presentations could be improved, after my first attempt I had a couple of comments about the colour of my hyperlinks and also the fact that I seemed to keep pacing forwards and then backwards which gave away how nervous I was. Thankfully I was voted through to the final and had an opportunity to improve the presentation over night.

The following day the final was at lunch time and I had to perform the same presentation again, I had changed the colour of my hyperlinks and was determined to make use of the entire stage as had been suggested by the judges from the previous heat, this surprisingly had the effect of taking my mind off of how nervous I was and I had a couple of comments from people who had said that my nerves didn't show through so that was could.

So all the presentations were over and it was up to the judges final decision, and they chose me...woo hoo cool! For all of my efforts I won an XBox 360 Elite with three games, nice!

John Mcloughlin and I did plenty of networking and made sure that we gave out as many NxtGen business cards as we could and also drummed up as much swag as possible, we also managed to secure a few sessions for the new year including the potential of a Microsoft Surface demo and talk after we had our own hands on experience of it.

All in all, I thought the Remix event was excellent and well worth attending (possibly slightly influenced by by winning a competition), special thanks goes out to Dave McMahon, Richard Costall and John Price (the NxtGenUG founders) for organising the Ready, Steady, Speak competition and allowing me to have this opportunity.

CSLA .NET at NxtGenUG Southampton

noreply@blogger.com (Richard Allen) — Wed, 10 Sep 2008 15:06:00 +0000

Tomorrow night, Thursday 11th September, we've got a great session lined up at NxtGenUG, Andrew Hallmark, Technical Architect from Maritz, is coming over to talk to us about the CSLA .NET framework and code generation tools.

If anyone managed to make to our session on Object Thinking by Alan Dean be sure not to miss this session, essentially Alan spoke about the theory behind Object Thinking and how we should be changing our approaches to developing object oriented. Well Rockford Lhotka, author of the CSLA, has based his "Expert Business Objects" framework upon some of those theories and in my opinion this is the closest you will get to an implementation of true Object Thinking. Even if you think you know CSLA already there may be a few tips and tricks and implementation ideas that you may find useful.

As usual there will be pizza and swag, so what are you waiting for sign up now and come along, see you there.

Ready, Steady, Speak at Remix 08

noreply@blogger.com (Richard Allen) — Mon, 08 Sep 2008 20:42:00 +0000

Next week, 18th and 19th September, sees the arrival of Remix 08 in Brighton and as seems to be the general trend at these big events of late, NxtGenUG are getting really involved and this time they'll be running another Ready, Steady, Speak competition similar to those seen at Tech Ed and the Microsoft 2008 UK Launch.

The general format is as follows:

Contestants will present a 5 min session on a subject of their choice relating to Web Development or Web Design. They will present in front of the REMIX audience and in front of a panel of judges. If there are more than a certain number of contestants (TBD), there will be ‘heats’ earlier in the day with the winners of the heats in a ‘speak-off’ in the evening session. The ‘speak-off’ will take place as stated in the evening of the first day of MIX and the first prize is an XBox 360 + Goodies!

Prerequisites:

Mandatory

· Speakers must NOT have previously presented ‘full sessions’ at DDD, TechEd, DevWeek, SDN, SQLBITS, VBUG Conference, NxtGenUG FEST or any similar such conferences.

· Speakers must create a new session of their own with new material which can be based on existing material but cannot be a simple copy of it.

· Speakers must limit their session to as close to 5 mins as possible( overrunning time will cause the speaker to be marked down.)

· Speakers must not have previously won Speaker Idol or “Ready Steady Speak” UK Launch – Sorry to James Coulter J!

· Speakers must state their desire to enter the competition by no later than COP Monday 15^th September 2008.

Desirable

· Speakers should provide if at all possible their own laptop, but one can be provided if necessary. The speaker should notify the organisers of any software prerequisites.

· Speakers should have spoken previously at a User Group meeting even if only for a 10 min mini-session or ‘nugget’. This is NOT mandatory

To show my support and get a bit of exposure to a larger audience for speaking, I have offered to join in the fun and take part in the competition with a slightly re-worked version of my WatiN nugget that I performed in Southampton last month. So I'll be spending the next couple of weeks getting really nervous and trying to figure out the best presentation I can muster.

Remix 08 looks set to be a great event including at least one session from Scott Guthrie, I'll be there and it would be good to see some of you there too (if not only for the moral support!).

WatiN, Ajax and some Extension Methods

noreply@blogger.com (Richard Allen) — Fri, 22 Aug 2008 16:58:00 +0000

Whilst I've been working with WatiN over the past couple of months I have encountered a few issues especially that unfortunately WatiN was unable to solve straight out of the box, so I thought I would knock a post together that contains the extension methods I have managed to cobble together from various sources on the Internet and a little bit from my own head.

WaitUntilEnabled

I encountered this issue whilst working with the CascadingDropDown provided by the Ajax Control Toolkit, now WatiN does provide a function called WaitUntil which allows you to pass in the name of the attribute you want to examine and the value that you expect the attribute to become, unfortunately however, it seems the CascadingDropDown adds a "disabled" attribute with a value of "true" to the html page. The drop down list then becomes enabled when the disabled attribute no longer exists or is set to false. Therefore it was necessary to write an extension method that waited until the control no longer had a "disabled" property with a value of "true. The method is as follows:

        /// <summary>
        /// Waits until the specified element is enabled within the web page.
        /// </summary>
        /// <param name="element">The element.</param>
        public static T WaitUntilEnabled<T>(this IElement element) where T : class
        {
            var timer = new SimpleTimer(IE.Settings.WaitForCompleteTimeOut);

            do
            {
                var value = element.GetAttributeValue("disabled");
                
                if (value != "True" && 
                    value != "true")
                {
                    return element as T;
                }
                Thread.Sleep(200);
            }
            while (!timer.Elapsed);

            throw new TimeoutException("Waited too long for " + element.Id + " to become enabled");
        }

UPDATED 15/09/08: Whilst preparing for my Ready, Steady, Speak session at Remix I came across a small bug where the value retrieved for the disabled attribute was "True" instead of "true" as initially thought, I don't know what caused the difference to occur but I have added the additional check anyway.

The usage of this method is as follows:

        ie.SelectList(Find.ById("MyCascadingDropDown")).WaitUntilEnabled().Select("AValue");

IfExists

This is just an extension method I wrote to make it a little easier to work with elements that don't exist:

        /// <summary>
        /// Checks whether the element exists, if so performs the specified action,
        /// otherwise just returns the current element object.
        /// </summary>
        /// <typeparam name="T">The type of element to check for existence.</typeparam>
        /// <param name="element">The element.</param>
        /// <param name="action">The action.</param>
        /// <returns></returns>
        public static T IfExists<T>(this Element element, Action<T> action) where T : class
        {
            if (element.Exists)
            {
                action(element as T);
            }

            return element as T;
        }

This method can be used as follows:

        ie.TextField(Find.ById("MyTextField")).IfExists<TextField>(e => e.TypeText("AValue"));

WaitForAsyncPostBackToComplete

If you are working with controls within an update panel you will inevitably come across a situation where a value is changed via an async postback and whilst that postback is taking place WatiN will try and perform another action which results in an error.The solution to this problem was found after searching the Internet for a little while and I came across this post which explains the problem in a little more detail.

I have modified the original method slightly to make it an extension for the IE browser object, it is used to determine whether the current page is within an asynchronous postback, unfortunately in order to use this method the page you are testing needs to have a JavaScript method defined so if you don't have control over the website you could be a little stuck, here is the Javascript:

<script type="text/javascript">      
    var prm = Sys.WebForms.PageRequestManager.getInstance();      
    function IsPageInAsyncPostback()
    {            
        return prm.get_isInAsyncPostBack();         
    }    
</script>

~~The C# method implementation is as follows:~~

        /// <summary>
        /// Waits for async post back to complete.
        /// </summary>
        /// <param name="ie">The ie instance to use.</param>
        public static void WaitForAsyncPostBackToComplete(this IE ie)
        {
            bool isInPostback = true;
            while (isInPostback)
            {
                isInPostback = Convert.ToBoolean(ie.Eval("IsPageInAsyncPostback();"));
                if (isInPostback)
                {
                    Thread.Sleep(200); //sleep for 200ms and query again 
                }
            }
        }

After a kind comment from Jo (see below), I have modified this as there is no need to place the IsPageInAsyncPostback method inside of the page, I just needed to modify the Eval method to make the entire call, as follows:

        /// <summary>
        /// Waits for async post back to complete.
        /// </summary>
        /// <param name="ie">The ie instance to use.</param>
        public static void WaitForAsyncPostBackToComplete(this IBrowser ie)
        {
            switch (ie.BrowserType)
            {
                case BrowserType.InternetExplorer:
                    {
                        bool isInPostback = true;
                        while (isInPostback)
                        {
                            isInPostback = Convert.ToBoolean(ie.Eval("Sys.WebForms.PageRequestManager.getInstance().get_isInAsyncPostBack();"));
                            if (isInPostback)
                            {
                                Thread.Sleep(200); //sleep for 200ms and query again 
                            }
                        }
                        break;
                    }
            }
        }

And can be used like this:

            SelectList list = ie.SelectList(Find.ById("MySelectList"));
            list.Option("TestOption").Select();
            
            ie.WaitForAsyncPostBackToComplete();
            
            SelectList childList = ie.SelectList(Find.ById("MyChildSelectList"));
            list.Option("TestChildOption").Select();

ByPartialId

The final useful method is ByPartialId, this is merely a wrapper around a regular expression but it does save quite a bit of typing and needing to remember the regular expression syntax. I found this on Ayende Rahien's blog:

        /// <summary>
        /// Gets an attribute constraint using a partial id.
        /// </summary>
        /// <param name="partialElementId">The partial element id.</param>
        /// <returns></returns>
        public static AttributeConstraint ByPartialId(string partialElementId)
        {
            return Find.ById(new Regex(".*" + partialElementId + "$"));
        }