OnTheBlog

Silverlight UK User Group #2 Agenda

Fri, 01 Aug 2008 14:13:23 GMT

Mark Mann form Conchango has posted some info on the agenda for the Silverlight UK user group on the 14th August. Unfortuantely I am out of country when this one is on. Gutted. But you can find out some more information here.

http://blogs.conchango.com/markmann/archive/2008/08/01/silverlight-uk-user-group-2-agenda-announced.aspx

and here

http://blogs.conchango.com/michelleflynn/archive/2008/08/01/silverlight-agenda-announced.aspx

SQL Server: How to page query results

Thu, 31 Jul 2008 17:20:11 GMT

The application I am working on at the moment has a large number of complex search screens that allow the user to define either very narrow or very broad query's. A great deal of effort has been spent in optimising the queries in order to ensure they are performant. However, if a user decided to execute a very broad query, the result set that could be returned could be many thousands of records. Let’s take a look at a broad query using this simple SQL.

Select ID, Forename, Surname

FROM Person Where Surname like '%DA%'

In this query we want to return everything from our person table where the surname contains the letter “DA”. Running this query gives us the following 99 results. I’ve randomized the data in our person data for privacy reasons.

Now this query is running on some test data but on a live system it might return 20,000+ records. Transferring this data from our DB server to our application tier, then into business entities and serialising them via soap to our client is going to be demanding process. This is not going to be a particulary great idea, a better approach would be to return results in pages so that we can maintain a responsive UI and reduced long running network calls.

Taking this example further, we lets say that we would like our page sizes to be 5 records each. The first page will return record 1-5 and when the user clicks next we require records 6-10 to be displayed. In order for us to be able to achieve this functionality we need to implement an index on our result set so that we can locate a particular page of data within the full results. To do this SQL server provides a handy function called which ROW_NUMBER()provides an incremental index for each record in our result set. If we implement the ROW_NUMBER()as part of our results we can see the results below.

SELECT ROW_NUMBER() OVER (ORDER BY (SELECT 1)) as [Index], ID, Forename, Surname

FROM Person Where Surname like '%DA%'

We can now see from executed query above that our results contain and INDEX column which uniquely identifies each row returned from our results. By adding this index to our results we now have a way of navigating batches of records within our results set. To do this is not as simple as just adding a WHERE to our SQL statement, instead we must execute the full query in order to determine our full set of indexes, then apply the WHERE on top of that. We can doing this using a sub-query.

SELECT ID, Forename, Surname

FROM (SELECT ROW_NUMBER() OVER (ORDER BY (SELECT 1))

AS [Index], ID, Forename, Surname From Person

Where Surname like '%DA%')

AS ResultSet

WHERE [Index] >= 6 AND [Index] <= 10

And the results

As you can see our results reflect only the range of records that we require from our overall result set. It’s important to note that the full query is still being executed in the background but we are reducing the burden on the results that are being sent to the client. So I hope this provides an alternative way to managing large result sets over the internet.

Silverlight 2: Control Templating & The Visual State Manager - PART 2

Mon, 28 Jul 2008 09:02:56 GMT

In my previous post we took a quick look at some of the support blend offers for skinning controls in Silverlight 2. Within only a few minutes we were able to take an existing textbox control and extend its visual tree using a custom template. In this post I plan to take our previous skinned control example further by implementing some simple animations. This is a good chance to check out the new VisualStateManager which greatly simplifies the development of animations in Silverlight.

For the basis of this tutorial we are going to extend our textbox template so that when a users places their mouse over the textbox the control will grow to make the text more readable. When the mouse leaves the textbox control the text will shrink again back to its normal “State”. It’s the word “State” here that really matters.

If you are observant and you haven’t moved all your panels around in blend, you may have noticed a new panel called states on the left hand side of your IDE. The states panel is a visual interface for managing the different states your control can be in. To help make this clearer, we can take a look at the control template for a button control (See previous post for how to do this in blend).

As you can see the standard Silverlight button control has a number of visual states that it can placed into. If we click on one of these states in the designer, our design surface will reflect what the look control will be in that state. As an example below, if we click on the disabled state we can see that the button looks greyed out.

What is important about the VisualStateManager is that it allows us to focus in a design centric way what each state looks like when the state is changed. In order to manage states more effectively you can see that Blend provides State Groups in which we can hold multiple visual states. We are not concerned with how we get to a particular state, we are just focused on the final look once we reach it. Some of the magic behind the VisualStateManager will be covered later.

So if we move back to our previous textbox example, we specified that we want the control to increase its size when a mouse rolls over the control and when the mouse leaves, the control should return to its original size. Given this, we know that our control can be in 1 of 2 states. Using blend, we are going to create a new state group and add two states to our control. Shown below.

As you can see, on the state group you have the oppurtinity to specify a default duration. This duration is a default that will be applied when a control transitions from one state to another. If you like you can ignore this but for the purpose of this example we have set or default.

If we click on our GROW state we can see our control displayed in the designer. We are going to make a simple change to our textbox properties by setting the fontsize on the textbox to 72. This is reflected in the designer as shown below.

If we click on our NORMAL state you will see the control looks how it did before the fontsize was changed. In terms of working in the designer we are now done, we have our begin state which is our BASE state and we have our transition state which is our GROW state and our final END state will be the NORMAL state. All we need to do now is invoke the state transitions when the appropriate events are fired. Before we do this we should take a quick look at the XAML Blend has created for us.

<vsm:VisualStateManager.VisualStateGroups>

<vsm:VisualStateGroup x:Name="StateGroup">

<vsm:VisualStateGroup.Transitions>

<vsm:VisualTransition Duration="00:00:00.5000000"/>

vsm:VisualStateGroup.Transitions>

<vsm:VisualState x:Name="Grow">

DoubleAnimationUsingKeyFrames>

Storyboard>

vsm:VisualState>

<vsm:VisualState x:Name="Normal">

vsm:VisualState>

vsm:VisualStateGroup>

vsm:VisualStateManager.VisualStateGroups>

You can see that the XAML pretty much represents what’s in the blend designer. We have a storyboard that has been placed within our Grow State that will apply our transition. The final part of the puzzle is to hook up event handlers to our textbox’s MouseOver and MouseLeave events. We do this in the standard way, by hooking up an event handler. I usually jump to visual studio for this work as we want to auto-create the event handler. See below.

MouseEnter="textBox_MouseEnter"

MouseLeave="textBox_MouseLeave"

private void textBox_MouseEnter(object sender, MouseEventArgs e)

{

VisualStateManager.GoToState(this, "Grow", true);

}

private void textBox_MouseLeave(object sender, MouseEventArgs e)

{

VisualStateManager.GoToState(this, "Normal", true);

}

In order to transition from one state to another the VisualStateManager class implements a static method that takes 3 arguments. The first argument is the control that we want to move form one state to another. In our case we use this as we are within our control If you want to call a state transition for a control your using it is just a matter of passing that control in instead. The second argument is the name of the state we want to move to and the final argument is a flag indicating if we want a transition effect.

After we have implemented our state transitions in code we are ready to go. I hope you can see how easy and powerful the VisualStateManger is and what it brings to Silverlight Apps.

You can see an example of this code running here and the full source can be downloaded here.

Silverlight 2: Control Templating & The Visual State Manager - PART 1

Thu, 24 Jul 2008 21:48:24 GMT

In this blog I wanted to provide a simple overview of some of the features provided as part of the June 2.5 Blend preview and Silverlight 2 Beta 2. Two of the key features that have been made available as part of this release is the ability to easily template controls in order to create your own custom skins as well as the new Visual State Manager which helps aid int the development of animations.

So lets get started. The first thing we want to do is have a look at how easy it is to create custom templates for controls using the June preview of Blend. We are going to create a simple Silverlight Application using the default project template provided by Blend. (Shown below)

Once Blend has created our project we need to create some very simple XAML. As this example is going to be VERY simple all we need to do is drag a textbox onto our design surface. Below shows the XAML of our form once this has been done.

<UserControl

xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"

xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"

x:Class="VSMDemo.Page"

Width="640" Height="480">

<TextBox Height="23"

Margin="139,147,159,0"

VerticalAlignment="Top"

Text="TextBox" TextWrapping="Wrap"/>

Grid>

UserControl>

Now that we have our basic XAML together we can start looking at the new templating support in Blend. If you select the textbox by using the document outline and right clicking you will now be presented with the following option.

Choosing the "Edit a Copy" will present you with the following dialog. Blend now offers you the choice to create a new style resource in a number of locations. For the purpose of the tutorial just take the default settings, this should create the style resource within our current document.

Whats really cool is that Blend will automatically take you into a design mode for editing the template.From here I made a few changes to the default template. My XAML looks like this after my changes.

<Setter.Value>

<Grid.Resources>

DoubleAnimationUsingKeyFrames>

Storyboard>

DoubleAnimationUsingKeyFrames>

Storyboard>

Grid.Resources>

<Border.Background>

LinearGradientBrush>

Border.Background>

Border>

<Rectangle.Stroke>

LinearGradientBrush>

Rectangle.Stroke>

Rectangle>

Grid>

ControlTemplate>

Setter.Value>

Setter>

Style>

The elements highlighted in yellow reflect the changes I have made to the default template. If we run our application at this point we can see what our template looks like.

So now you can see just how easy it is to create our own control skins within Blend. In part 2 we will extend this example to show you the new VisualStateManager which greatly increases our productivity when creating cool looking animations.

Part 2

Fluent Language Interfaces

Mon, 14 Jul 2008 20:57:27 GMT

I was having think about fluent language interfaces and got me thinking about the power they can offer. Take this example for searching the web.

Web.Search
       .Contains("David").And.Contains("Hanson")
      .Or.contains("Michael Smith")
      .Exclude("Sex")
      .Exclude("man, Word, Slipper")

      .WithinDomain("www.ontheBlog.Net")
      .OutPutFormat(Format.XML)
      .Provider(Provider.Google | Provider.LiveSearch)
      .FilterLevel(Filter.None)
      .MaxResult(100)
      .Language(Language.English)
       .Execute();

I may have to take this further.

RIA's and Search Engines 2.

Wed, 02 Jul 2008 15:35:17 GMT

A while back I blogged about the the trend in web content being developed using Rich Internet Application technolgies such as Flash & Silverlight. Previous Blog

Well an interesting announcement comes from Adobe which looks to address some of these issue going forward. Snippet below. Full article on business week here. Story.

"Flash, software, Adobe, Google, Yahoo, search engine, Web, Macromedia, photos, animationIf you're trawling the Web to buy a pair of Nikes, shop for a Volkswagen, or get a glimpse of Walt Disney's Wall-E, chances are you'll end up viewing graphics built with Adobe Systems' Flash software. Good luck finding them with a search engine, though. Turns out Google and other Web-search tools can't easily recognize pages laden with Flash-created images.

At least not yet. Adobe (ADBE) announced steps to solve those problems on July 1, providing Google (GOOG) and Yahoo! (YHOO) with software that will make pages inside Flash-powered sites show up higher in search results and infuse those results with more relevant details. Adobe's moves could persuade more consumers to visit its customers' sites and make Flash software more attractive to Web site developers. Adobe's agreements with the two biggest search engines on the Web is also a competitive slap at Microsoft (MSFT), which makes Web software that competes with Adobe's."

Free Download Manager

Sat, 21 Jun 2008 11:35:45 GMT

Over the last few weeks I have been using the following product found here (http://www.freedownloadmanager.org/features.htm) which provides some cool features for downloading. Since using it I am starting to get the most of out of my 20mbps cable connection. The reason is due to the fact that the when downloading, the software creates multiple HTTP connections to the file. Check this download speed for the Silverlight 2 Beta 2 tools. Awesome.

Great speed for downloads

Key features

Multiple HTTP connections for a single download (Make downloading ALOT faster)
Automatically resumes on broken connections
Torrent support
Media Previews for partially downloaded files
Download only certain files held in a zip file.
Download entire sites

Screen shot

Cross-Platform DRM Support for Silverlight 2 Beta 2

Sun, 08 Jun 2008 16:32:14 GMT

I was having a read through of the feature set for Silverlight 2 Beta 2. One of the items that instantly stood out for me was the fact that with Beta 2 Support for DRM (Digital Rights Management) has made it, and more importantly...........IT’S CROSS BROWSER AND CROSS PLATFORM! Now let me be clear on this, I am not a fan of DRM as I believe as a consumer I have the right to use the content I have paid for in anyway I choose. I’m not suggesting copying and passing on too friends is fairplay but I do feel I should be able to duplicate the media for all the devices in my home. That said, although I am not a fan of DRM personally, I can greet this news with optimism and here is why.

About 18 months ago I was working on a contract for Siemens who were developing the packaging and delivery of the BBC IPlayers content. This was interesting work and really opened my eyes to the amount of effort that must go into launching a platform like the IPlayer. 18 months ago none of us working on the project had any idea as to how successful the IPlayer would be, therefore the application was built with performance and scalability in mind. A good thing too given the way it panned out.

While working on the project, one area I felt was seriously lacking was the cross platform support. All content delivered via the VOD system is encrypted using Windows DRM. As the name suggest, the result that decision was that all content inevitably becomes locked into the windows platform. Therefore unless you’re on a windows platform, the IPlayer would be useless to you.

The BBC were not the only ones to adopt this approach, SKY, ITV and Channel 4 have all built their VOD platforms on the Kontiki P2P system using Windows DRM. So as a guy with a Mac (Yes I run windows vista on it) I could consider myself up shits creek! So the question is, why is this good news? It’s good news as whether we like it or not DRM is essential for large media conglomerate when it comes to delivering their content over the web. Whether we like it or not, I still cannot see them dropping it due to public demand. Therefore, with Silverlight providing the tools necessasary for cross-platform DRM, adaptable streaming and the ability to generate amazing RIA’s there are very little hurdles left to overcome.

I expect to see the BBC move this way as they have previously confirmed that Mac support was on their todo list. Also some of the demo’s from MIX07 with the BBC Radio 1 site delivered via Silverlight show the potential. I am hoping to have a play with the new Silverlight 2 Beta 2 features in the next few weeks so expect some posts then.

Isle of Wight Festival and my technology addiction!

Sat, 07 Jun 2008 17:37:29 GMT

I'm off to the Isle of Wight festival this week and as usual I have spent the weekend getting all the essentials together. I've got my tent dusted down, wellies, wet wipes beer and much more ready to go. However I am starting to think that I am a little to addicted. Here is a rundown of the gadgets i'm taking.

IPod Touch
ITrip
Stereo to transmit music from IPod too.
Solar Charger
Camera
Mobile Phone
Walkie Talkes
Windup torch
Smartphone

Something tells me I may need to lock my tent up!

The power of Silverlight vectors

Fri, 23 May 2008 10:58:53 GMT

As you probably know the power of WPF and its subset Silverlight is its ability to render images using vector graphics. I am not a graphic designer myself, I can usually get a decent design together but it’s usually more evolutionary rather than revolutionary.

As all images in vector graphics are expressed using mathematics they provide computers with some superior processing capabilities that are not possible with common binary formats. We can transform them, scale them, animate them to name just a few . However, with the advantages of having an image represented in mathematics, we also suffer with increased complexity when trying to create them from scratch.

With the current release of Silverlight, we have the power in the framework to represent near photo realistic images purely in vectors. Take for example the photo of me shown below, this image, running in Silverlight, has been built using only vectors. You can see this running in Silverlight here.

Bad Mood

If we take a closer look at the structure of the eye, we can see that the complexity of the XAML path objects, which are the basic building blocks used to compose the image, are far beyond the capabilities of any human designer using tools such as Blend or Visual Studio.

The image was actually constructed using the cool site vectormagic.com. On this site you can upload any photo and it will convert the image to vectors. This covered off the majority of the grunt work of converting the image into vectors. VectorMagic offer you two free downloads in a range of formats.... but no XAML option. Therefore, I downloaded the file in Adobe Illustrator format, from there it was a simple process of exporting the image into XAML using Mike Swanson’s awesome AI-XAML converter.

Hope this quick example has helped illustrate the power of Silverlight’s graphical capabilities and gets you thinking about what other assets you could convert into XAML.

.NET 3.5 SP1 & Visual Studio 2008 SP1 Beta released

Tue, 13 May 2008 08:31:57 GMT

It seems .Net 3.5 SP1 and Visual Studio 2008 SP1 beta are now available from Microsoft for download. This release brings a number of fixes for hundreds of bugs that have been reported by customers.

This download installs Visual Studio 2008 SP1 Beta. Visual Studio 2008 SP1 includes support for SQL Server 2008, new ADO.NET features such as the Entity Framework, improvements to the WPF designers, WCF templates for Silverlight projects, debugger support for the .NET Framework public symbols and source release, control improvements such as the DataRepeater for Windows Forms and Office 2007 Ribbons for C++, and several general updates for debugging and IntelliSense. SP1 also enhances the stability, performance, and security of many features.

The included .NET Framework 3.5 Service Pack 1 adds many new features and fixes, including the following:

.NET Framework Client Release (“Arrowhead”)

· ASP.NET Dynamic Data

· ASP.NET Routing

· ADO.NET Data Services

· ADO.NET Entity Framework

I’m just hoping that it resolves the constant OutOfMemory exceptions I get when working with the WPF designer. You can find the downloads here.

http://msdn.microsoft.com/en-us/vstudio/cc533448.aspx

Oldest running code?

Mon, 12 May 2008 09:08:03 GMT

Slashdot poses an interesting question asking what is the oldest code still running today. Of the 600+ comments so far I have cherry picked a few that I thought were good choices.

· The software on the Voyager and Pioneer SpaceCraft 1977

· Digital watches

· Heavy machinery used from the late 50’s

· Babbage Difference Engine (Currently running in the science museum London)

· Worryingly – Air Traffic controls system code from the 60’s

· DNA – At least 2 billion years old! J

But my personal favourite!

1 "Let there be light"

2 create universe()

3 while (1)

Cosmic Crashes

Tue, 29 Apr 2008 19:51:56 GMT

I was catching up on some podcasts during my drive to work recently and came across an interesting topic on the BBC's Digital Planet podcast. The discussion was regarding the “impact” cosmic rays can have on our desktop computers and more importantly very expensive grid platforms such as IBM’s Blue Gene. Computer crashes can be annoyng to the average user but on grid platforms running simulations that require accurate data they can be very costly. During the podcast they had interviewed with an Intel researcher (who's name I have forgotten sorry) who was discussing his strategies for counter acting the effects these highly energetic particles can have.

Before I outline his proposal it’s probably worth explaining some rudimentary physics.

What is a cosmic ray?

Answer: A cosmic ray is a particle with mass greater than zero that has been been accelerated to a speed that is approaching the speed of light.

How does it get that fast?

Answer: A range of cosmic events can cause this but let’s just say for this blog, a star exploded millions of years ago and that it is this explosion that caused the cosmic ray.

I heard that most cosmic rays just pass right through us.. How come?

Answer: Well thanks to Mr Einstein we know that with increased mass comes an exponential increase in energy in order to accelerate the matter towards light speed. Therefore cosmic rays are generally low is mass. As a result, they can pass through the atoms in your body undisturbed. (Well mostly)

So how do cosmic rays cause computer crashes?

Answer: Computers processors are based on logic gates which manage the flow of electrons on the processor. When a cosmic ray hits the processor a surge or peak of energy is releases in the form of electrons which can result in the processor providing inaccurate results. (Hence it crashes).

So with the details out of the way I can get on to explaining what the Intel researcher was planning to in order to resolve this problem. Basically, his view on cosmic crashes was that it’s going to be almost impossible to stop them from happening, insulating the processor with cosmic ray impenetrable materials is going to be very hard, very large and expensive. So, instead he proposed that what we should do is build detectors which can identify the surge of electrons associated with a cosmic ray and then instruct the processor to rerun the previous calculation that may have been affected.

I must say... I like his thinking.

LINQ to Reflection Part 3: Updating Fields

Mon, 28 Apr 2008 13:30:07 GMT

In part 2 of this LINQ 2 Reflection series I took you through how we go about querying fields that may existing within an object graph. Before we proceed, it’s important to remember that a call to object.Field will return an instance of type Linq.Reflection.Field. As part 2 focused purely the reading fields it’s about time we take a look at how we can go about updating them. If we look at the intellisense that Visual Studio provides for the Field class we can see that this class has an Update method. Shown below.

Firstly, as the Update method is contextual, there is no requirement to pass the name of the field we wish to update as this can be inferred from its parent. Secondly, As the Field returns a generic class of type T it also allows us to infer the Type of value we wish to update. Below is a simple update statement on a person entity.

person

.Field<string>("_firstName").Update("James")

.Field<string>("_lastName").Update("Brown")

.Field<DateTime>("_dateOfBirth").Update(DOB);

The Update method of the Field class returns an instance of the parent object we are currently working with. Internally the Field class passes the parent context down our chained methods. Therefore we have the ability to move up the object graph if so desired. In this situation, where we are updating 1 of many fields on the parent context, its important that the return value from Update is that of the parent object.

As that’s pretty much it for updating fields using LINQ to Reflection. You can call the Update on and Field or Property accessor. As this point in our series you have the information you need to drill down any object reading and writing property/field values to suit your tests scenarios.

In part 4 we will start looking at how we can leverage the power of these extensions methods by showing how we can mock internal objects without breaking the rules of encapsulation.

LINQ to Reflection Part 2: Reading Fields

Fri, 25 Apr 2008 11:34:23 GMT

In part 1 of my LINQ to Reflection series I outlined some of the key drivers behind me creating a set of extension methods that can be used to query any CLR type. I also outlined that I am looking to extend this further with support for reading/writing of data, mocking, invocation, interception and other useful behaviours. This post is purely focused on the reading of field data using the LINQ to Reflection extension methods.

Before we get into the details of how we query data, we first need to create some tests data that will be used for each sample. Below is a method that is used to build object graph that is comprised simple and complex types with multiple child objects. Note: We are already starting to use our LINQ to Reflection methods in order to create tests data.

///

/// Sets up an object graph for our different test scenarios.

///

public static Person GetTestData()

{

Person person = new Person();

return FillPerson(person,3, 4);

}

///

/// Fills the person with test data.

///

///The person.

///The levels deep we wish to populate.

///A person instance

private static Person FillPerson(Person person,int noOfChildren, int levelsDeep)

{

//Update our name.

person

.Field<string>("_firstName").Update("Joe")

.Field<string>("_lastName").Update("Blog " + levelsDeep.ToString());

//Add a Partner

Person partner = new Person();

partner.Partner = person;

person.Partner = partner;

//We have reached or level.

if (levelsDeep == 0)

return person;

else

{

//Lets create the children for this person.

for (int i = 0; i < noOfChildren; i++)

{

Person child = new Person();

//Add children.

person.Children.Add(FillPerson(child, 4, levelsDeep - 1));

}

return person;

}

The result of this method is a person being created with children, grandchildren, great grandchildren and great great grandchildren. Each generation will have a lower number appended to their name. Therefore a 4 equates to the oldest and 0 equates to the youngest. This is shown in the locals window below.

Now that we have some tests data to work with it’s about time we starting looking at some LINQ to Reflection samples. As mentioned in part 1, LINQ to Reflection provides extension methods for the Object type. This therefore means, if you import the LINQ.Reflection namespace, every single CLR type in scope is queryable. This includes base types such as string, int, decimal, object & any other type. Below is a an example of the intellisense being displayed on a string class once the LINQ.Reflection namespace has been imported.

Having the extension methods available on all .net types & at any point is one of the features I consider the most compelling. You will also notices that the extension methods use .NET generics, this is vitally important as I felt type safety and intellisense support is invaluable when you are digging many levels deep into an object graph. I am hoping as we start to delve deeper you start to see the benefits of these decisions.

Sample 1 – Reading Fields from an instance.

string firstName = person.Field<string>("_firstName").Value;

DateTime DOB = person.Field<DateTime>("_dateOfBirth").Value;

Console.WriteLine("First Name: {0} - Year Born: {1}", firstName, DOB.Year);

This example shows how we can read fields held on an instanced type [Person]. FYI these fields are private. LINQ to Reflection allows you to read fields on any type whether private, protected, internal & public. In order to read a field we use the Field> extension method. We pass the type argument to the Field method in order to strongly type the value we are going to be accessing person.Field<DateTime>. Next we need to pass the name of the field we are trying to access, we do this using the name parameter ("_dateOfBirth").The final part is to call the Value property which will return a strongly typed value from the field. The result of running this code is shown below.

First Name: Joe - Year Born: 1978

Sample 2 – Reading complex fields from an instance.

In the previous example we are accessing fields on our person instance using fairly simple types. However, the Field method allows us to use generics therefore we can pass any type we desire into the type argument. Often fields that sit within an object are complex in nature, they maybe other entities, collections or connections etc. This example shows the Field method being called in order to return a strongly typed collection of persons .Field<List<Person>>. We then iterate around this collection writing out each person’s name and age.

List<Person> children = person.Field<List<Person>>("_children").Value;

foreach(Person child in children)

     Console.WriteLine("First Name: {0} - Year Born: {1}", person.Name, person.Age);

The output from this code is shown below.

First Name: Joe Blog 4 - Age: 29

First Name: Joe Blog 4 - Age: 29

First Name: Joe Blog 4 - Age: 29

Sample 3 – Reading a field where the type is inaccessibly.

At this point you may be wondering what you do in the situation whereby you do not know the type of the field. In these situations you can down cast the field to its lowest common denominator for example a custom collection could be converted to a List or an entity could be downcast to an object. Below is an example of accessing a field that you do not know the type of.

person.Field<Object>("_dateOfBirth").Value;

Sample 4 – Obtaining a list of available fields.

During testing of your own objects you often know what internal fields are being used. Therefore obtaining the name is not an issue. However, some types you wont and therefore you need a way to interrogate the object in order to determine the field name. The Fields extension method provides this functionality. It returns a collection of Linq.Reflection.Field objects which can be used to read values or alternatively drill down deeper. Below is an example of reading all fields on the string class.

foreach (Field<object> field in "hello" Fields())

    Console.WriteLine("Field Name: {0}", field.Name);

And the result of running this code is shown below.

Field Name: m_arrayLength

Field Name: m_stringLength

Field Name: m_firstChar

Field Name: Empty

Field Name: WhitespaceChars

Field Name: TrimHead

Field Name: TrimTail

Field Name: TrimBoth

Field Name: charPtrAlignConst

Field Name: alignConst

Sample 5 – Finding a field with LINQ to Reflection and LINQ to Objects.

This example shows how we can use our LINQ to reflection extension methods to obtain a list of Fields and then perform a LINQ query on our collection in order to find a specific field.

IEnumerable<Field<Object>> fields = "Hello"

                                        .Fields()

                                        .Where(field => field.Name == "alignConst");

foreach (Field<Object> f in fields)

    Console.WriteLine(f.Name);

The output from this code is shown below.

alignConst

Sample 6 – Reading fields from deep inside our object graph.

Now that you have seen how we can access fields on our top level object we will now look at how we can drill down into our object graph. As the Field extension method returns a representation of a Field and that we can access the value of that field using the Value property, we can continue to dig deeper. Below is an example that well drill down each of the children collections that hangs of a person until we read the bottom.

Person greatGreatGrandson = person

                            .Field<List<Person>>("_children").Value[0]

                                .Field<List<Person>>("_children").Value[0]

                                    .Field<List<Person>>("_children").Value[0]

                                        .Field<List<Person>>("_children").Value[0];

Console.WriteLine("Great great grandson : {0}", greatGreatGrandson.Name);

The chaining of Field methods allows us to step down the tree each step returning a strongly typed person collection. You can see this as we access the indexer on the collection. [0].. If we run this code we get the following result. The “Joe Blog 0” represents the last generation in our tree. Note... if we were to chain another Field method we would hit a null reference exception.

Great great grandson : Joe Blog 0

So that completes Part 2 of this blog series. From this you should be able to grasp the way that field data can be read from any type of object. Further, you can see how the power of chaining allows us to writing code that represents visually what we are trying to attain. You will see this pattern repeated later on when we look at property data, method and constants. In Part 3 however we will look at how we can perform updates on data by extending these samples.

WPF: Could not create an instance of type '{0}'

Fri, 25 Apr 2008 09:10:57 GMT

If you get this error in your designer when working with XAML in Visual Studio 2008...make sure you dont have any visual elements that inherit from an abstract class. May seem obvious but can be easily missed.

Could not create an instance of type '{0}'

The rise and fall of social networks

Wed, 23 Apr 2008 19:47:05 GMT

It seems every six months a new social network is on the scene. If I was to guess who currently reigns supreme I would imagine facebook is likely to be in there. Google trends provides us with some insights into this question.

facebook, myspace & bebo

I will run this graph in a year and see how its changed. Until then make your own minds up.

Linq to Reflection: Part 1

Wed, 23 Apr 2008 09:25:08 GMT

Firstly.... before you read this, I would really like feedback on this series of posts and the ideas it outlines. I wanted to get that request made on the first line as apparently most humans skip the next paragraph when searching for info. So with that out of the way I will outline what this post is really about.

These posts are the result of a bit of a mishmash of ideas that I have been thinking about of late. The project I am currently working is fully agile, therefore test driven development plays a key role in the day to day work a developer encounters. We perform integration testing, interaction testing, unit testing & business testing as well as a few other kinds of testing during the course of writing functionality. The project has also recently migrated.NET 3.5 and a result we have started to take advantage of some of the languages features such as LINQ.

When I first heard of LINQ I must admit I was sceptical. I am one of those developers who likes to have a thorough understanding of the architecture prior to implementing it my code base. (Remember VB web classes anyone). I picked up the Pro-LINQ book from Apress a while back and spent a weekend reading from cover to cover. So before I continue I will clarify my position on these technologies.

LINQ to Objects is superb.

LINQ to XML is just as good.

LINQ to SQL is good but not there yet! (Release 3 Perhaps).

LINQ to Entities (Barge pole and touch come to mind).

So with that said I will try and move onto the focus of these posts. LINQ to Objects has been implemented using .NET 3.5 extension methods. Extension methods allow you to implement instance type methods on existing classes. Even if these classes are sealed or you do not have the source code so you can extend them. So given this new feature it got me thinking about what possible uses there are for extension methods. LINQ uses them primarily on types of IEnumerable in order to implement query expressions, but I wanted to see if I could use them in a more generic fashion on any type of object.

As I felt I had a solution looking for a problem, I decided to bide my time and wait for the problem to present itself. A couple of weeks ago it did!! As said, we are working on a project which has adopted TDD. One of the issue I find with TDD is that I kept feeling I had to break encapsulation principles in order to increase testability. An internal field on a class would need to be set for a specific test condition to pass or an object deep down in my object graph would need to be configured or mocked in order to allow testing. IOC & dependency injection admittedly can help in this area but are not always the simplest of solutions. So end game is that I want to avoid this wherever possible.

Currently, In order to solve some of these problems, our project has a number of utility classes for accessing private members on a reference types. This only goes so far and can be cumbersome to use. What I would ideally like in my tool kit is the ability to seamlessly drill down an object graph using a familiar syntax. More than that, I want to be able to instantly convert those fields or properties to mock objects prior to running my tests. I want to be able to swap mock frameworks without changing my tests and think more about my test conditions instead of the mocking framework. I want a repeatable pattern.

As a result of this I have started work on a library which will provide a simple LINQ 2 Reflection style syntax which will provide facilities for drilling down into any CLR type and performing a number of tasks ranging from (Reading data, Writing data , Mocking , Invocation, monitoring, interception and many other extensible behaviours.).

In part 2 I will start to outline some simple uses of these LINQ to reflection extension methods. For the timing being here is a very simple update statement using the extension methods on a person entity.

            DateTime DOB = new DateTime(1950, 1, 1);

            //Lets perform an Update on our entity.

            person

                .Field<string>("_firstName").Update("James")

                .Field<string>("_lastName").Update("Brown")

                .Field<DateTime>("_dateOfBirth").Update(DOB);