OnTheBlog

PDC 2010 cast doubt on Silverlight but what does it really mean?

Sun, 31 Oct 2010 21:40:04 GMT

In case you have been living in a hole for the last week I imagine you have probably heard on the blogsphere about the demise of Silverlight now that HTML 5 is here and Microsoft are backing it. Without getting into the details of why they would do this, I think generally its a supersmart approach for the Blue man group. HTML 5 is here to stay as far as standards for the web go its the best we've got.

Either way over the weekend I had a long thought about what it means and I eventually came to the conclusion that it won't make much a huge difference and that Silverlight & xaml based technologies won't be going anywhere. The reason is that although HTML 5 does provide a number of new RIA features such as vector based drawing, socket programming, asynchronous operations etc. It will still lack hugely when it comes to developing sophisticated line of business applications. It will also never be at the forefront of innovation. Technologies and trends change and proprietary tech such as Silverlight and Flash will be at the forefront of this change.

A good rule of thumb is that if an application is not going to need to be deployed to the public web as most LOB's aren't then Silverlight will be the natural fit. However if it's a commercial application available to the public then HTML 5 would be a better fit. Besides I would be surprised if at some point we don't see a Silverlight to HTML compiler to bridge that gap.

Eitherway change is good and that's why we are in this game!

That's my 2 pence anyways.

Windows Phone 7 Emulator standalone installer (July bits)

Sat, 24 Jul 2010 05:27:22 GMT

Hello out there.

Well I haven't updated this site for about 6 months and I thought I would try and be a little more active. The reason for my lack of posts is that I am currently in Australia travelling in a campervan and connectivity has been a bit of issue. The distraction of sunshine and beautiful sights doesn't help either.

Anyways I have just started getting to grips with the July Windows Phone 7 Beta tools and came across annoying issue with the installer. Basically it makes you download 300mb of data as part of the install. As I only wanted to download the Emulator (specifically the x64 version) I hunted around the installed settings file (located in a temp directory) an eventually stumbled upon the following two links which allow you to download it seperately. Hope this helps someone else who had this problem.

http://go.microsoft.com/fwlink/?LinkId=194975

http://go.microsoft.com/fwlink/?LinkId=194976

PS. Word to MS. Stop using online installers.... they are driving me mental on a flakey 3g connection in the bush!

Introducing #Fellows

Fri, 19 Mar 2010 20:58:27 GMT

Just a quick note to make readers aware of a new blogging site called #Fellows. This community site aggregates the blogs of a number of smart .Netters from the UK. Enjoy.

Rx, Reactive Extensions and Observable T

Tue, 26 Jan 2010 10:31:57 GMT

I have been seeing quite a lot of talk on the tweet feeds and blog posts recently about the new Reactive Extensions that are being released. Now I was struggling to get my head around it at first but read this simple blog post which really helped clarify what Rx actually offers. It seems very powerful, and could be a game changer for event processing in the same way Linq was for list data. Really like the drag and drop example in this post as it becomes very clear the intention of the code shown below.

Define the events you wish to monitor

var mouseDown = from evt in Observable.FromEvent<MouseButtonEventArgs>(image, "MouseDown")
select evt.EventArgs.GetPosition(image);

var mouseUp = Observable.FromEvent<MouseButtonEventArgs>(image, "MouseUp");

var mouseMove = from evt in Observable.FromEvent<MouseEventArgs>(image, "MouseMove")
select evt.EventArgs.GetPosition(this);

Then define your query which will tie these events together into a logical form for your requirement (In this case drag and drop)

var q = from imageOffset in mouseDown
from pos in mouseMove.Until(mouseUp)
select new { X = pos.X - imageOffset.X, Y = pos.Y - imageOffset.Y };

And then finally subscribe to the query and perform the action we would like to process.

q.Subscribe(value =>
                {
                    Canvas.SetLeft(image, value.X);
                    Canvas.SetTop(image, value.Y);
                });

What's really cool about all this is that the event subscriptions will be marshalled onto the correct thread thus avoiding cross thread access violations. VERY COOL!

Calling a generic method with Expression.Call

Sun, 17 Jan 2010 09:05:54 GMT

The other day I came across a comment in the code base of the application I'm currently working on that said the following.

// Having to loop through the GetMethods() array is pretty rubbish, even if we are using LINQ. If someone knows how to use GetMethod to get the generic method definition, then correct the code, email me and I'll buy you a pint.

Now looking into this issue it turns out that the author is correct, you cannot actually use Type.GetMethod() to invoke a Generic Method. As a result the approach the dev used was to call Type.GetMethods() which returns all methods on the type and then apply some linq filtering to identify the generic method they wish to invoke. Once filtered a quick call to MakeGenericMethod then you can invoke it. This is shown below.

typeof(FrameworkHelper)

.GetMethods()

.Where(method => method.IsGenericMethod && method.Name == "DeleteEntity")

.Select(method => method.MakeGenericMethod(actualEntityType))

.First()

.Invoke(null, new object[] { entity });

So having a think about this for a bit and then recalling some great blog posts I had read from Bart De Smet's blog about expression tree's I wondered if we could use the Expression.Call method to achieve the same results. After some tinkering with the overloads for this method I eventually figured it out and result is shown below.

ParameterExpression param = Expression.Parameter(typeof(Entity), "param");

var method = Expression.Call(typeof(FrameworkHelper), "DeleteEntity", new[] { typeof(Entity) }, param).Method;

method.Invoke(null, new object[] { entity });

In the code above we create an instance of a Parameter expression which requires the Type of the parameter we are going to pass to the method. Then in order to invoke the method we need to build the call expression on line 2. Here we use the Expression.Call static method which has a number of overloads.

The first param is the type which holds the static method we wish to invoke, the next paramter is the method name which is passed as string. The third paramter is the types that the method signature defines. This is passed as an array of objects. Finally is the ParamExpression we constructed on the previous line. The final part once we have the methodInfo is to invoke it by passing the instance of Entity.

The Expression class supports a huge array of static methods which can be used to build code dynamically and with .NET 4.0 we get a lot more support for more complex issues such as flow control, block statements etc.

Hope this quick sample sparks your interest for Expressions support in .net.

Update - Had an email from Bart about this post and he has suggested an elegant approach to this problem. Bart's approach below.

You could also have the C# compiler do all the work for you and write a simple helper method (assuming you don't need to find the method by an externally provided name at runtime...):

static MethodInfo GetMethod(Expression e)
{
return ((MethodCallExpression)e.Body).Method;
}

Now call this as follows:

GetMethod(() => new int[0].Select(x => x.ToString()))

This will return the MethodInfo for Enumerable.Select.

Hope this helps,
-Bart

Raising binding exceptions in WPF & Silverlight with .net 4.0 Dynamics

Mon, 14 Dec 2009 14:00:19 GMT

It’s been a while since I’ve posted anything. Sorry about that. This has mainly been due to a busy social and work schedule which has not given me the time I’ve needed to create the content that’s been floating around my desk as post it notes. In this post I would like to revisit dynamic typing support in .NET 4.0 and apply it to a real world scenario.

Proxying and Interception with Dynamics

If you’re like me then I imagine you have been playing with .NET 4.0 for quite a while now. There is a wealth of new language features to play with in this release and I’m excited about the RTM come march. One of the features I have discussed previously is the support for dynamic typing. Dynamics brings with it some new approaches to problems that static languages have often found difficult to solve. In this post we will be looking at the topic of dynamic proxying, interception and AOP.

The common goal of these techniques is to allow a programmer to be able to inject code transparently before and after a method has been invoked. This is illustrated below in the diagram below.

If you have not come across this concept before you may ask what is the point of intercepting a method before and after execution. A layer of indirection is particularly useful when trying to inject code between a client and our objects. The reason we do this as it allows us to implement secondary support functions such as logging, transaction management, code contracts and other utility code outside the body of our method. What we find when we implement an proxy pattern is that once we have removed this secondary code the readability of our code improves tremendously and we have also increased our separation of concerns.

Now you can see the benefits of this approach, let’s turn our attention to how we go about implementing this in our code. Luckily for us there has been a lot of smart people working hard to help make this process easier. If you do a search for proxy pattern’s or aspect orientated programming you will find a heap of information. When it comes to AOP there are a number of frameworks which have already been developed. These are listed below.

Aspect#

Encase AOP

Spring.NET

Aspect.NET

AspectDNG

Dynamic Proxy

Compose*

Loom.NET

PostSharp

Each of these frameworks make use of a number techniques to the injection of code both before and after execution of a method. These generally fall into 4 categories.

MSIL injection – Here we inject MSIL code into the body of the method being executed. (Post sharp)

Runtime dynamic injection – Using techniques such as reflection we invoke methods dynamically.

Type builder injection – Related to runtime injection, we create a type based on the type we wish to proxy and then marshal requests through this type. (Dynamic Proxy)

Container injection – Requests pass through a container which invokes code before and after our method being executed.

WPF Bindings with dynamic objects

So now that C# 4.0 brings with it support for dynamic objects I thought I would take a look at how I can go about implementing a simple interception pattern for static objects. I am currently working on a project which makes extensive use of WPF. We follow and MVP pattern and our views are bound directly to our presenters in order to reduce the amount of code in our views. If you have worked with WPF you will probably know some of the great benefits of the binding model. Using simple XAML expressions you can bind controls to properties deep down in your object graph. However, sometimes you need to do something a little more complicated. If you have use data templates for list controls you may have found the need to bind to something that’s way up the visual tree. Below is a good example of this.

In this scenario I have bound a button command to a command definition which sits on my presenter. However, you will notice I made a deliberate mistake. I spelt the word command wrong in the path. As a result WPF will fail to locate the binding and when I actually click on this button nothing will happen. This is frustrating and there things I can do to identify this issue. Bea Costa has some good posts around this topic here. The problem with these approaches are that none of them are particularly obvious to the developer.

What I would really like is to be able to throw an exception whenever a binding fails. I would also like to show debug statements printed in my output window when a binding access occurs. As I already have a substantial codebase that I do not have the time or urge to go through in order to support this functionality I want to do it in a low impact way.

Building the Dynamic Binding Interceptor

When we look at how I bind my presenter you can see it’s a fairly simple affair. My view Implements IBindableView which exposes the Views DataContext to the presenter. Therefore it’s a trivial process for creating the binding.

View.DataContext = this;

It at this point where I would like to attack the problem at hand. As dynamic objects use dynamic dispatch to query a type, my best approach is to set the views data context to be a dynamic object of my choice and then route the requests to my presenter. The key thing here is that I do not want to change my existing presenter code in anyway. I want my binding code to look like this.

View.DataContext = new BindingInterceptor(this);

Given that, I need to create my new interceptor class and implement the behaviours I mentioned. To do this we need to create a new class that inherits from DynamicObject and provide a constructor which takes our source for binding. This class is show below.

///

/// Provides interception of properties for bound objects.

///

public class BindingInterceptor: DynamicObject

{

protected dynamic Source{ get; set;}

public BindingInterceptor(dynamic source)

{

Source = source;

}

You can see that we store the source for future use. The interception of properties will be achieved by overriding two methods on DynamicObject. These are shown below.

public override bool TryGetMember(GetMemberBinder binder, out object result)

{

return base.TryGetMember(binder, out result);

}

public override bool TrySetMember(SetMemberBinder binder, object value)

{

return base.TrySetMember(binder, value);

}

These two methods will be invoked whenever our View tries to access a property on its data context, which in our case will be the our BindingInterceptor. It would be a simple task to implement the desired behaviour of logging and throwing exceptions within our BindingInterceptor, however on this occasion I would like something a little more flexible. Instead I would like to be able to instruct the BindingInterceptor of the behaviours I would like it to execute before and after accessing a property. Looking back at our binding code, I would now rather it looked more like the following.

bindingInterceptor

.OnGet

.BeforeGet((binding) => Debug.WriteLine(string.Format("TRY GET: Name={0}", binding.Name)))

.AfterGet((binding, value) => Debug.WriteLine(string.Format("GET RESULT: Name={0}, Value={1}, Result={2}", binding.Name, value, "Success")))

.IfGetException((binding, exception) => { throw new BindingException(string.Format("Failed to Get [{0}]", binding.Name), exception); })

.OnSet

.BeforeSet((binding, value) => Debug.WriteLine(string.Format("TRY SET: Name={0}, Value={1}", binding.Name, value)))

.AfterSet((binding, value) => Debug.WriteLine(string.Format("SET RESULT: Name={0}, Value={1}, Result={2}", binding.Name,value, "Success")))

.IfSetException((binding, exception) => { throw new BindingException(string.Format("Failed to Set [{0}]", binding.Name), exception); });

Although this code is more verbose, it does allow me to specify exactly what I would like implemented on access of properties. It also uses a fluent interface which to a reader who is new to the code should be relatively easy to follow. In order to implement this in our BindingInterceptor we need to add a few simple methods which will take an Action as their input and return an instance of the BindingInterceptor. These methods are shown below.

public BindingInterceptor OnGet { get { return this; } }

public BindingInterceptor OnSet { get { return this; } }

public BindingInterceptor BeforeGet(Action<GetMemberBinder> beforeGet)

{

BeforeGetPropertyDelegate = beforeGet;

return this;

}

public BindingInterceptor AfterGet(Action<GetMemberBinder, object> afterGet)

{

AfterGetPropertyDelegate = afterGet;

return this;

}

public BindingInterceptor BeforeSet(Action<SetMemberBinder, object> beforeSet)

{

BeforeSetPropertyDelegate = beforeSet;

return this;

}

public BindingInterceptor AfterSet(Action<SetMemberBinder, object> afterSet)

{

AftersetPropertyDelegate = afterSet;

return this;

}

public BindingInterceptor IfGetException(Action<GetMemberBinder,Exception> getException)

{

GetExceptionDelegate = getException;

return this;

}

public BindingInterceptor IfSetException(Action<SetMemberBinder,Exception> setException)

{

SetExceptionDelegate = setException;

return this;

}

Now we have the ability to inform the BindingInterceptor of the behaviours we would like it to carry out, the final task for us to do is make sure that the these behaviours are invoked and that the value is marshalled to and from our source presenter. I have highlighted this below.

private void GetValue(GetMemberBinder binder, out object result)

{

try

{

if (BeforeGetPropertyDelegate != null) BeforeGetPropertyDelegate(binder);

Type type = Source.GetType();

result = type.GetProperties().FirstOrDefault(p => p.Name == binder.Name).GetValue(Source, null);

if (AfterGetPropertyDelegate != null) AfterGetPropertyDelegate(binder, result);

}

catch (Exception exception)

{

if (GetExceptionDelegate != null) GetExceptionDelegate(binder, exception);

}

private void SetValue(SetMemberBinder binder, object value)

{

try

{

if (BeforeSetPropertyDelegate != null) BeforeSetPropertyDelegate(binder, value);

Type type = Source.GetType();

type.GetProperties().FirstOrDefault(p => p.Name == binder.Name).SetValue(Source,value,null);

if (AftersetPropertyDelegate != null) AftersetPropertyDelegate(binder, value);

}

catch (Exception exception)

{

if (SetExceptionDelegate != null) SetExceptionDelegate(binder, exception);

}

To test our BindingInterceptor I need to create a simple user interface. I want to be able to bind two presenters, one good presenter that meets all the requirements of the bound controls and one bad presenter that wont.

When we click the “Bind good presenter” option we use our BindingInterceptor to wrap our presenter instance and then set this as the data context of the window. Doing this provides us with the following output in the debug window.

----------------BEGIN GET--------------------

TRY GET: Name=LikeDynamics

GET RESULT: Name=LikeDynamics, Value=True, Result=Success

----------------END GET----------------------

----------------BEGIN GET--------------------

TRY GET: Name=WantToSeeMore

GET RESULT: Name=WantToSeeMore, Value=True, Result=Success

----------------END GET----------------------

----------------BEGIN GET--------------------

TRY GET: Name=Comments

GET RESULT: Name=Comments, Value=Good presenter is bound., Result=Success

----------------END GET----------------------

You can see the initial binding of the data context causes our control bindings to refresh the values from their source. Each of these requests is serviced via our BindingInterceptor. If we then uncheck the “I like .net 4.0 dynamics?” checkbox we can see the value being passed from the windows through our interceptor and into our good presenter.

----------------BEGIN SET--------------------

TRY SET: Name=LikeDynamics, Value=False

SET RESULT: Name=LikeDynamics, Value=False, Result=Success

----------------END SET----------------------

----------------BEGIN GET--------------------

TRY GET: Name=LikeDynamics

GET RESULT: Name=LikeDynamics, Value=False, Result=Success

----------------END GET----------------------

Now we have met the first objective of our interceptor class. We have provided a level of logging without having to change our existing presenter code. Our second objective was to raise exceptions when a binding fails. We do this by selecting the “Bind Bad Presenter” option which does not have the properties required for binding.

----------------BEGIN GET--------------------

TRY GET: Name=LikeDynamics

System.Windows.Data Error: 17 : Cannot get 'LikeDynamics' value (type 'Object') from '' (type 'BindingInterceptor'). BindingExpression:Path=LikeDynamics; DataItem='BindingInterceptor' (HashCode=7063836); target element is 'CheckBox' (Name=''); target property is 'IsChecked' (type 'Nullable`1') BindingException:'DynamicInterceptor.BindingException: Failed to Get [LikeDynamics] ---> Microsoft.CSharp.RuntimeBinder.RuntimeBinderException: Cannot perform runtime binding on a null reference

This time we can see that the request to read the property “LikeDynamics” fails with an Binding exception. This is as expected as we defined this in our BindingInterceptor behaviours. However, unfortunately for us the application does not raise any exceptions and therefore the binding is invisible. This is NOT what we want. The reason this occurs is due to the fact that when WPF attempts to access a binding it is wrapped in an TryCatch block and the exception is hidden. As part of this post I did take the time to look through the .NET source code and actually found the code where this occurs. I noticed that all exceptions are ignored accept a number of Critical exception types. These exceptions such as StackOverflow, OutOfMemory, NullReference are the only ones which will bubble up to the surface. Therefore If I want my custom binding exception to be raised, I need to ensure the exception inherits from NullReferenceException. Making this small change and rebinding to the bad presenter now causes an exception to be thrown.

Conclusion

In this post I wanted to introduce a new approach to proxying using c# 4.0 dynamics. This simple example should have provided you with a good insight into interception techniques. From there it opens the door for whole range of exciting opportunities to solve complex problems. You can see the code required to implement this pattern is minimal. I plan to follow up this post with a series of posts which will outline some cool uses for dynamic interception in a range of problems. This approach can be used for both Silverlight and WPF as Microsoft are making great efforts to support dynamics across technologies.

If you want the source code for this post you can download it here.

Defensive coding source available.

Sun, 13 Dec 2009 09:57:57 GMT

I had a request to make the defensive coding source code available. So here you go.

Download

Extension method to find the nearest common ancestor of a given type.

Thu, 10 Sep 2009 14:51:25 GMT

I had a problem recently where I had an inheritance hierarchy of which I needed to find a common ancestor type between two objects. Below shows a quick mock up of the situation I faced.

As you can see the Person type is the common ancestor for both Student and Teacher. In order to solve this issue I decided to write the following extension method for the Type type to be able to locate it easily in the future. Code below for anyone interested. Hope it helps.

///

/// Extension methods for the Type

///

public static class TypeExtensions

{

///

/// Finds the nearest common ancestor for a given type.

///

/// The type.

/// Type of the target.

///

public static Type FindCommonAncestor (this Type type, Type targetType)

{

if (targetType.IsAssignableFrom(type))

return targetType;

var baseType = targetType.BaseType;

while(baseType != null && !baseType.IsPrimitive)

{

if (baseType.IsAssignableFrom(type))

return baseType;

baseType = baseType.BaseType;

}

return null;

}

RDL Parameter Reader

Fri, 28 Aug 2009 08:17:58 GMT

I currently working on retro fitting some SQL server reports into the application we are building. I needed a quick way to view all the parameters each report uses. The code below is a quick snippet to do just that. Just point it at a directory with the RDL files in an away you go. Note: This code does the bare minimum and is used for SQL Server 2005 RDL. I haven't checked to see if it works on SQL 2008 RDL. Thought it might help someone.

public Report()

{

Parameters = new List<Parameter>();

}

public string ReportName { get; set; }

public List<Parameter> Parameters{ get; set;}

}

///

/// Represents a report parameter.

///

public class Parameter

{

public string Name { get; set; }

public string DataType { get; set; }

public string DefaultValue { get; set; }

public string Hidden { get; set; }

}

///

/// Gets the report parameters.

///

/// The location.

public static List<Report> GetReportParameters(string location)

{

if (!Directory.Exists(location.Trim()))

Console.WriteLine("Could not find the location specified");

//Get the RDL files

var directoryInfo = new DirectoryInfo(location);

var rdlFiles = directoryInfo.GetFiles("*.rdl");

var reports = new List<Report>();

//For each file we will extract the parameters.

foreach(var fileInfo in rdlFiles)

{

var report = new Report {ReportName = fileInfo.Name};

var xDocument = XDocument.Load(File.OpenText(fileInfo.FullName));

var parameters =

xDocument.Descendants()

.Where(node => node.Name.LocalName == "ReportParameters")

.Nodes()

.Select(param => XElement.Load(param.CreateReader()))

.Select

(

param =>

new Parameter()

{

DataType = SafeRead(() => param.Elements().FirstOrDefault(xe => xe.Name.LocalName == "DataType").Value),

Hidden = SafeRead(() =>param.Elements().FirstOrDefault(xe => xe.Name.LocalName == "Hidden").Value),

Name = SafeRead(()=>param.Attribute("Name").Value)

}

)

.ToList();

report.Parameters.AddRange(parameters);

reports.Add(report);

}

return reports;

}

NDC 2009 Videos

Fri, 03 Jul 2009 10:25:54 GMT

· Tim Huckaby - Jump into Windows Presentation Foundation! ...and Become Immediately Effective

· Scott Hanselman - Deep Tour of .NET 4

· Ted Neward - Why the Next Five Years Will Be About Languages

· Michael Feathers - Seven Blind Alleys in Software Design

· Jonas Follesø - MVVM Patterns for Silverlight and WPF applications

· Scott Hanselman - Making Your Blog Suck Less: Social Networking and Your Personal Brand Online

· Luca Bolognese - The Future of C#

· Udi Dahan - Reliability, Availability, and Scalability - How to have your cake, and eat it too

· Michael Feathers - Working Effectively with the Legacy Code: Taming the Wild Code Base

· Tim Huckaby - Declarative UI Programming with XAML: Windows Presentation Foundation, Silverlight & Surface

· Phil Haack - Black Belt Ninja Tips ASP.NET MVC

· Michael Feathers - Functional Thinking for Object-Oriented Designers

· Robert C. Martin - Clean Code: Functions

· Jeremy D. Miller - Lessons Learned from a Long Lived Codebase

· Ian Griffiths - Writing Custom Windows Presentation Foundation Pixel Shader Effects

· Phil Haack - ASP.NET MVC + AJAX = meant for each other

· Luca Bolognese - An Introduction to Microsoft F#

· Tim Huckaby - Building Data Visualization Applications with the Windows Presentation Foundation

· Phil Haack & Scott Hanselman - The Haacked and Hanselman Show

· Ted Neward - The Busy Developer's Guide to ECMA(Java)Script

· Jonas Follesø - Building Business Applications in Silverlight 3

· Udi Dahan - Intentions and Interfaces - Making Patterns Complete

· Jeremy D. Miller - Presentation Patterns for Composite Applications

· Ayende Rahien - Writing Domain Specific Languages in Boo

· Tim Huckaby - Integrating Windows Presentation Foundation and Windows Communications Foundation into Your Office Business Applications

· Michael Feathers - Design Sense Deep Lessons in Software Design

Defensive Coding

Fri, 05 Jun 2009 06:33:18 GMT

How often have you seen code like this?

private void AllocateRoles(RoleChangeInfo roleChangeInfo)

{

foreach (Role role in roleChangeInfo.Roles)

{

if (roleChangeInfo.Person.Age > 21 && roleChangeInfo.Person is Senior)

RoleChangeService.AddRole(rolechangeInfo.Person, role);

}

If we deconstruct this code we can see that the method AllocateRoles should received an instance of a RoleChangeInfo which is a container for all the information that is required to add the roles to the appropriate person. If we take a look at the implementation of this type we can see that it’s fairly simplistic. It holds the ID of the Role and a RoleTaken DateTime.

public class Role

{

public int ID { get; set; }

public DateTime? RoleTaken { get; set; }

}

The body of the AllocateRoles method consists of a simple ForEach iteration around the Roles collection and with each role we check to make sure the person is older than 21 and they are of type senior. If both of these conditions are true then we call the RoleChangeService.AddRole method which will perform the work and update the RoleTaken.

I have come across this kind of code many times in the past and it is a good example of where a developer has made a number of assumptions and have not thought about making the AllocateRoles method defensive. So before we jump into making this code defensive let’s take a look at some of the possible issues with this code. Can you see them?

Developer Assumptions

· That roleChangeInfo will not be null

· That the Roles collection will be initialised

· That each role within the Roles collection will not be null

· That the roleChangeInfo.Person will not be null

· That it is ok to call this method when the Person is not a senior

· That it is ok to call this method with when the person is younger than 21

· That it is ok to call this method and no roles are present.

· That it is ok to exit this method without checking to see if our Role.RoleTaken has been set.

· None of the Roles.RoleTaken stamps have already been set.

From the list of items above you get the idea. The code in AllocateRoles takes the path of least resistance and should invalid data be passed in no specific exceptions will be raised. This can result in two possible outcomes. Firstly, the code crashes with a null reference exception and we spend hours trying to find the cause of the issue or the code executes a scenario that is considered invalid. This can lead to data corruption and a large headache trying to figure out where it’s happening.

Enter Defensive coding – When we apply defensive coding techniques to this method we are trying to attain 2 possible outcomes. Firstly we wish to identify all possible errors within our method and throw exceptions if any of them are met. Secondly, we want to ensure that no business functionality will be executed accidently and that the results of our code is sound. Given this, let’s take another stab at our AllocateRoles method.

private void AllocateRoles(RoleChangeInfo roleChangeInfo)

{

//CHECK: that we have a valid rolechangeInfo and that we have a Person and that the person

//is of type Senior and that the roles collection is not null.

if (roleChangeInfo != null && roleChangeInfo.Person != null

&& roleChangeInfo.Person.GetType() == typeof(Senior)

&& roleChangeInfo.Roles != null)

{

// CHECK: that we actuall have roles.

if (roleChangeInfo.Roles.Count == 0)

throw new ApplicationException("You must specify at least one role.");

foreach (var role in roleChangeInfo.Roles)

{

// CHECK: we dont have a null role.

if (role == null)

throw new NullReferenceException("Role cannot be null");

// CHECK: that the Role Taken has not been set.

if (role.RoleTaken != null)

throw new ApplicationException("Role has already been taken.");

// CHECK: that the Persons ages is not less than 21.

if (roleChangeInfo.Person.Age < 21)

throw new ApplicationException("You cannot allocate roles to seniors under 21");

//DO OUR WORK HERE

RoleChangeService.AddRole(rolechangeInfo.Person,role)

}

// CHECK: all roles have a taken date.

if (roleChangeInfo.Roles.Exists(role => role.RoleTaken == null))

throw new ApplicationException("Role taken date has not been set.");

}

As you can see the method implementation above now performs a number of checks on the input data and where appropriate throws exceptions if the state is invalid. At this point we could consider this method defensive enough for our purposes. However by implementing numerous checks on the state of the data we have lost readability of our business logic. Secondly the checks are scattered throughout the method and the very first check still falls through and can exit with no code being run. In most cases I may not mind this but others I may want to ensure fall through does not occur. The result is that I would have to break apart this check into multiple If’s. Not ideal.

Enter Arrange, Act, Assert - If you are familiar with unit testing you may have come this pattern when creating your tests. If you haven’t I suggest you have a quick read here. But the basics of this pattern are that you arrange your code in a way so that the Act you are performing can execute with the desired effect and that after the work is done you can assert any failures. Once you get the hang of it it certainly makes writing tests easier. Given this, I want to refactor the method so that a reusable pattern can be established when performing defensive coding. If we look at our pattern is follows the following workflow.

Assert (Input) >> Act >> Assert (Output)

Given this pattern and I what I want to achieve, I needed to create a simple utility class that would allowing me to perform daisy chaining of conditions which can then be executed at a given point. The Defensive methods such as IsNull would return instances of themselves allowing semantics such as the following.

Defensive.CurrentMethod

.IsNotNull(test, "Message")

.IsInstanceOfType(new object(), typeof(object), "Type does not match")

.IsTrue(() => 1 == 2, "1 wont equal 2")

.Check();

Using this new utility class we can now go back to our AllocateRoles method and refactor to meet AAA pattern we use in our tests. Below is the final defensive method.

private void AllocateRoles(RoleChangeInfo roleChangeInfo)

{

//ASSERT Inputs

Defensive.CurrentMethod

.IsNotNull(roleChangeInfo, "Cannot call AllocateRoles without a roleChangeInfo")

.IsNotNull(roleChangeInfo.Person, "You must have a valid Person reference")

.AnyNull(roleChangeInfo.Roles, "You must specify roles")

.IsInstanceOfType(roleChangeInfo.Person, typeof(Senior), "You can only apply roles to senior people")

.IsTrue(() => roleChangeInfo.Person.Age > 21, "You cannot allocate roles to seniors under 21")

.IsTrue(() => roleChangeInfo.Roles.Count > 0, "You must specify at least one role.")

.Check();

//ACT

roleChangeInfo.Roles.ForEach(role => RoleChangeService.AddRole(rolechangeInfo.Person, role));

//ASSERT Outputs

Defensive.CurrentMethod

.IsTrue(() => !roleChangeInfo.Roles.Exists(role => role.RoleTaken == null), "Role allocation failed.")

.Check();

}

You can see that the AAA syntax coupled with the daisy chaining allows for our defensive checks to be grouped together at the top and bottom of our method. This avoids diluting our business code with numerous checks. Defensive coding is a powerful tool in our arsenal when it comes to increasing the resilence of our application code.

Microsoft® Silverlight™ 3 Tools Beta 1

Wed, 18 Mar 2009 15:02:54 GMT

Want to start developing for Silverlight 3.0? Well you can now download the tools you need for Visual Studio from Microsoft.

Download here

Silverlight 3: Some info!

Wed, 18 Mar 2009 10:46:11 GMT

Today see's the start of MIX09. As a result I decided to look on the agenda for the sessions that are taking place over the next few days and I came across this little nugget if information on Silverlight 3. The session is titled "What's new in Silverlight 3" The brief synopsis gives us a sneak peak as to what to expect from Scotts Keynote.

"Take a tour of the new features in Silverlight 3 including a dive into some of the new experience oriented features like pixel shaders, perspective 3D, animation enhancements, bitmap APIs and improvements to the media stack. Also hear about new Silverlight base framework additions including updates to the style model, data binding improvements, improved resource handling and improvements to the web services stack."

Looking forward to those 3D demo's already!

Next SLUG Meeting: Thursday 26th March 2009

Tue, 17 Mar 2009 13:51:00 GMT

So it s been a while since I have blogged. I wont bore you with the details but what with moving home, project commitments and lots going on in my personal life I've just not had time to focus. This post is to get me started again .

The next SLUG meeting has been announced. You can find details of it here . Its going to follow a GROK TALK format, this means that anyone can have 15 mins talking to the group about experiences they have had with Silverlight. Mark is also looking for MIX attendees to come along and share their thoughts on this years announcements etc.

Is BizTalk Dead - Part 2

Wed, 26 Nov 2008 21:18:25 GMT

Back at the beginning of the year I wrote a blog post about the awkward conflict that BizTalk faced now that WF was on the scene. Although at the time of writing there was an obvious cross over between the products, BizTalk still offered a number of key advantages over bog standard workflow. Due to some emails I received I decided to look around Microsoft's code projects and see what I could find. It was way back in Feb that I came across OSLO.

9 Months later and with PDC out of the way, OSLO and Microsofts strategy for WF is far more clear. OSLO seemed to evolve over the last few months into the codename primarily used for the modelling language and toolset announced. Microsoft also showed off a whole new version of WF for .NET 4.0. This new version of WF comes with some major improvements.

WF has been rewritten from the ground up.
Performance has been dramatically increased
Services and Workflow can be written purely with XAML
A new customisable designer surface
Large number of new activities for developing workflows
Seamless integration with WCF

So with WF being upgraded to a spanky new version which offers a wealth of new features please bare in mind that BizTalk'ers are still waiting for their orchestration engine to be updated to use the new WF engine. Given the new version of WF being announced I would be wondering how long its going to take before I see that in BizTalk?

Back to the original OSLO article I found way back in Februrary, the article talked of a new WF hosting engine. This part of the puzzle we now know has been codenamed "Dublin". If you haven't heard of Dublin yet and your into BizTalk then hold your breath as the diagram below (taken from MSDN) may look familiar.

Dublin is the application server that has long been missing from the Microsoft product set. Announced to be a part of Windows Server , Dublin provides a runtime which hosts WF workflows and provides services for persistence, tracking, management, message forwarding and much more. The Dublin runtime is implemented on SQL Server server which allows WF developers to create long running workflows. Prior to Dublin this was only possible by either rolling your own or implementing BizTalk.

Is this sounding familiar to you? Well it doesn't stop there I'm afraid. Dublin can also run as part of farm of servers whereby each instance can use a single shared persistence store. Dublin also provides automatic workflow activation as part of its message routing architecture.

As you can see Dublin is the future. Even Microsoft recognise the awkward overlap of features as evidenced by this MSDN article.

For anybody familiar with BizTalk Server, looking at “Dublin” might cause a slight sense of déjà vu. Supporting workflow-based logic, providing a monitoring and management infrastructure: These are things that BizTalk Server does today. What’s the future of BizTalk Server in a “Dublin” world?

The key thing to understand is that “Dublin” doesn’t directly target traditional BizTalk scenarios. For example, enterprise application integration and business-to-business connections via EDI will still use BizTalk Server. Similarly, bringing existing applications into the service-oriented world by exposing their functions and/or data through BizTalk Server will continue to make sense. While the reach of “Dublin” may grow over time, BizTalk Server remains important for connecting the Microsoft application platform to the diverse systems common in most enterprises.

If an organization needs an application container for WCF services, however, especially those implemented using WF, “Dublin” is a better choice—this is what it’s designed for. And expect BizTalk Server’s connection with “Dublin” to get stronger: Look for a future release after BizTalk Server 2009 to build on the “Dublin” infrastructure. Even though the functions of BizTalk Server and “Dublin” appear to overlap in some ways, each technology has a clear role to play.

So where do we stand? In my opinion I think BizTalks days are numbered, apart from some BAM, Adaptors and some tools there is very little separating the two technologies. Key to remember is that Dublin is where the innovation is happening and I dont expect to see that change. If your a BizTalk dev today I recommend getting yourself orientated with WF and Dublin asap.

Silverlight 3D confirmed!

Mon, 17 Nov 2008 14:16:48 GMT

Scott Gu has a post today highlighting a couple of features that we can expect to see in Silverlight 3. Good to hear on the list are the following

• Increased databinding support (Lets hope we get element binding)
• 3D graphics support (With GPU Acceleration)
• H.264 Codecs for high quality video streams.

His full post can be found here.

C# 4.0 and Dynamic Objects Part 1

Thu, 13 Nov 2008 00:19:26 GMT

Over the last week I have been watching a number of sessions that were recorded at PDC. One that I particularly enjoyed was Anders Hejlsberg “Future of C#”.

During this talk Anders provides a brief introduction to dynamics support in C#. If you’re not sure what dynamics really are then the best way to describe it is the ability to perform lazy evaluation of an objects data type & members at runtime. To make this clearer we can look at C# as it stands today as a purely static language. If we define a new class within c# 3.5 show below we are generally bound to use only the members that have been defined on the contract.

public class PlainOldObject

{

public string Name { get; set; }

public int Age { get; set; }

}

Now when it comes to using the PlainOldObject class we can only do so in a limited way as compilation will fail if we try to access properties that do not exist. Take for example

PlainOldObject plainOldObject = new PlainOldObject();

plainOldObject.Name = "Dave Hanson";

plainOldObject.Age = 30;

plainOldObject.FavouriteLanguage = "c#";

This fails compilation with an error of “'PlainOldObject' does not contain a definition for 'FavouriteLanguage'”. In order to get this code to compile in our current c# 3.5 code we need to go back to the class and implement a new property called FavouriteLanguage of type string.

Introducing the Dynamic Type

Dynamics support in c# 4.0 solves this issue for us! In C# 4.0 a new static type is being introduced called dynamic. The dynamic type tells the c# compiler to ignore type checking at compile and instead leave the evaluation until runtime. The dynamic type can be applied to any .net type but more importantly it can be applied to external resources such as XML, COM objects and Scripts.

So given we have late binding of members now supported in C# 4.0 with the use of the dynamic type what will our code example from above look like. This is show below.

dynamic plainOldObject = new PlainOldObject();

plainOldObject.Name = "Dave Hanson";

plainOldObject.Age = 30;

plainOldObject.FavouriteLanguage = "c#";

As you can see the code looks almost identical. Apart from the dynamic keyword nothing else has changed. However, under C# 4.0, when you go to compile you will not be faced with a compilation error as was shown before. At this point we can see that the compiler is no longer checking all the members of the type during compile but we are still faced with the issue that our PlainOldObject does not actually implement the property FavouriteLanguages. In fact, running the code will cause an exception to be throw.

The next issue we need to solve is how we go about create a dynamic object that can be extended arbitrarily. To do this, we follow the approach most dynamic languages follow. As types have no fixed structure in dynamic languages they must store their data in a generic way, therefore they often implement an internal collection within the type which will store data for each dynamic property is set. Implementing this pattern in C# 4.0 is relatively straight forward.

Introducing DynamicObject

In order for us to create our own dynamic objects Microsoft have provides us with an abstract class called DynamicObject. This abstract class has a number of virtual methods which we can override and that provide interceptors for all method invocations, property getters and setters as well some other useful functions. This is shown below.

public abstract class DynamicObject : IDynamicObject

{

public virtual object GetMember(GetMemberBinder info);

public virtual object SetMember(SetMemberBinder info, object value);

public virtual object DeleteMember(DeleteMemberBinder info);

public virtual object UnaryOperation(UnaryOperationBinder info);

public virtual object BinaryOperation(BinaryOperationBinder info, object arg);

public virtual object Convert(ConvertBinder info);

public virtual object Invoke(InvokeBinder info, object[] args);

public virtual object InvokeMember(InvokeMemberBinder info, object[] args);

public virtual object CreateInstance(CreateInstanceBinder info, object[] args);

public virtual object GetIndex(GetIndexBinder info, object[] indices);

public virtual object SetIndex(SetIndexBinder info, object[] indices, object value);

public virtual object DeleteIndex(DeleteIndexBinder info, object[] indices);

public MetaObject IDynamicObject.GetMetaObject();

}

So in order to allow our PlainOldObject to support dynamic behaviour we need to inherit the DynamicObject class and then override the GetMember and SetMember methods. In our implementation of these methods we need to ensure that if the SetMember is called we place a value into the internal dictionary of values held within PlainOldObject and if the GetMember is called we need to retrieve the value. Below is an example of this code.

public class PlainOldObject : DynamicObject

{

private Dictionary<string,object> _members = new Dictionary<string,object>();

public override object GetMember(GetMemberAction member)

{

return _members[member.Name];

}

public override object SetMember(SetMemberAction member, object value)

{

_members[member.Name] = value;

}

And that’s it.... were done. We now have an extensible dynamic object that can be extended without having to implement new properties.

dynamic plainOldObject = new PlainOldObject();

plainOldObject.Name = "Dave Hanson";

plainOldObject.Age = 30;

plainOldObject.FavouriteLanguage = "c#";

plainOldObject.Height = 6.0;

plainOldObject.Sex = "Male";

plainOldObject.Foo = "Bar"

Silverlight UK usergroup session video - 1

Wed, 12 Nov 2008 14:58:28 GMT

If you didn't manage to make it to the Silverlight UK user group last week then you may want to check out this video below. This is session one by TrickyBusiness who outline there design approach. Enjoy.

" + __flash__argumentsToXML(arguments,0) + "")); }" extractposterframe="function () { return eval(instance.CallFunction("" + __flash__argumentsToXML(arguments,0) + "")); }">

Goodbye Linq to SQL?

Fri, 31 Oct 2008 13:44:31 GMT

An interesting post has arrived on the Ado.net team blog with regard to the future of LINQ to SQL. Although not coming outright and saying it, it seems that LINQ to SQL is likely to be deprecated in the future in favour of Entity Framework.

“We’re making significant investments in the Entity Framework such that as of .NET 4.0 the Entity Framework will be our recommended data access solution for LINQ to relational scenarios”

So this leaves the question, what will customers who have implemented LINQ to SQL do for long term support. I would like to see Microsoft provide clear guidelines and tooling in order to help those unfortunate ones migrate their existing software forward. The good news is that the awkward gap between LINQ to SQL and EntityFramework now seems to have been resolved.

New Silverlight Controls

Wed, 29 Oct 2008 23:02:25 GMT

For those of you coming from WPF to Silverlight you often find yourself frustrated when you find that Silverlight is lacking some very useful controls that you take for granted. Well today at least that gap is narrowing..... As here you will find on codeplex the Silverlight Toolkit. http://www.codeplex.com/Silverlight

With this release you get additional layout controls such as Dockpanel, ViewBox, Wrap panels etc as well as some more advance controls such as expanders and charting!

I heard a while back these would becoming as an additional download so glad to see them finally arrive. Expect ALOT more in the near future!

PDC: Office via Silverlight

Tue, 28 Oct 2008 20:34:47 GMT

Well there are announcements coming left right and center from PDC this year. We've heard about Azure and Microsoft's move to provide cloud services. We hear details of Oslo and Dublin and what they will mean for the future of language developement and modelling.

And then one very important announcment from Microsoft which shows their commitment to Silverlight and related technologies is the announcement that the next version of Office will come with a web enabled version powered by Silverlight. Their is a video posted on Channel 9 about this that shows small demos of Silverlight Word, Excel and One Note. VERY COOL!

This is the future of RIA's and software as a service and I am looking forward to see how Microsoft's competitors continue to compete now that Silverlight and .Net are going cross platform.

New .NET Logo!

Sun, 26 Oct 2008 08:36:35 GMT

Well after 8 years Microsoft has decided to update the .NET Logo. I always like the old one but I think the new one is even better.

I've read in the blogs that this new logo is already in place around PDC. One thing about this logo is that it brings a feeling of familiarity and I'm not sure why. Perhaps its because it uses similar colours and gradients as those found in Photoshop CS3?

Silverlight 2 Released!

Tue, 14 Oct 2008 11:22:00 GMT

Well its official, Silverlight 2 is now complete and available to the public. The full press statement can be read here.

http://www.microsoft.com/presspass/press/2008/oct08/10-13Silverlight2PR.mspx

The total download size weighs in at 4.64Mb so still pretty compact. Hats of to Microsoft for squeezing so much functionality in!

Highlights of new Silverlight 2 features include the following:

• .NET Framework support with a rich base class library. This is a compatible subset of the full .NET Framework.

• Powerful built-in controls. These include DataGrid, ListBox, Slider, ScrollViewer, Calendar controls and more.

• Advanced skinning and templating support. This makes it easy to customize the look and feel of an application.

• Deep zoom. This enables unparalleled interactivity and navigation of ultrahigh resolution imagery.

• Comprehensive networking support. Out-of-the-box support allows calling REST, WS*/SOAP, POX, RSS and standard HTTP services, enabling users to create applications that easily integrate with existing back-end systems.

• Expanded .NET Framework language support. Unlike other runtimes, Silverlight 2 supports a variety of programming languages, including Visual Basic, C#, JavaScript, IronPython and IronRuby, making it easier for developers already familiar with one of these languages to repurpose their existing skill sets.

• Advanced content protection. This now includes Silverlight DRM, powered by PlayReady, offering robust content protection for connected Silverlight experiences.

• Improved server scalability and expanded advertiser support. This includes new streaming and progressive download capabilities, superior search engine optimization techniques, and next-generation in-stream advertising support.

• Vibrant partner ecosystem. Visual Studio Industry Partners such as ComponentOne LLC, Infragistics Inc. and Telerik Inc. are providing products that further enhance developer capabilities when creating Silverlight applications using Visual Studio.

• Cross-platform and cross-browser support. This includes support for Mac, Windows and Linux in Firefox, Safari and Windows Internet Explorer.

NHibernate Query Generator

Fri, 10 Oct 2008 11:01:38 GMT

My good friend Andrew Clancy at Conchango has written an interesting blog post about the benefits of using the NHibernate Query Generator. We have been actively using this in our project and we find benefits every day. Check it out.

Blog post here

Remix 08: Silverlight Info and Leaks

Tue, 23 Sep 2008 19:54:04 GMT

Scott demonstrating ASP.net MVC

Well Remix is over and my thoughts post event was that it was a bit of let down. Unfortunately PDC is right around the corner and as a result no new major announcements were being made. Before attending I made a promise to myself to mix equally between design and development orientated sessions.

While there I got to speak to some great people and discuss topics ranging from visualisation techniques to the duplex communication in Silverlight. I was also lucky enough to grab a few moments of Scott Gu’s time and discuss a few Silverlight specifics.

No MergeDictionaries for RTM - I was mortified to hear that MergeDictionaries is not going to make it into the RTM. I cannot believe that we have to specify all our styles and resources in our App.xaml for the foreseeable future. This is particularly annoying if you are trying to migrate a WPF app to Silverlight.

H264 will miss RTM – I kind of expected this one as it was only recently announced. But Scott clarified it.

Charting controls coming – It looks like the Silverlight team are working hard on more advanced controls and Scott let slip that charting controls are to be included.

Silverlight automatic update – In one of Scott’s sessions he confirmed that Silver light 2 Beta 2 installs will automatically upgrade to the RTM.

Ribbon bar for WPF on track – It looks like the Ribbon for WPF should be due sometime this year. I asked if we can expect to see this in Silverlight soon and he confirmed it was NOT on the current development schedule. (Damn).

Silverlight not the preferred platform – I asked Scott if I could expect to see innovation happening in the Silverlight space from now on given that the VSM was developed for Silverlight first. Scott said there was no particular decision on which came first, however they will be trying and reduce the issue of code portability between WPF and Silverlight apps.

And Finally - 3D was pretty much confirmed. When asked by a member of the audience when will we see 3D support in Silverlight Scott’s grin couldn’t be hidden. He kept saying “Well that would be a compelling option”. I’m expecting to see this announced at PDC.

So generally I had a good couple of days but felt some of the session’s could have been a little more tech and less big picture. Next year perhaps.

Great looking silverlight Ribbon bar!!

Sat, 13 Sep 2008 08:55:05 GMT

I was surfing the web this morning and I came across this impressive Office Ribbon bar implementation by Simon Matthews at Infusion. He has uploaded a demo of the control and at it is mightly impressive.

I will be following his work eagerly as its something so far I think Microsoft has failed to deliver to developers. Why they have not delivered these controls I am not clear, but my hunch is that they are trying to capitalise on the uniqueness of the ribbon bar in office before they allow the rest of us the goodness. Eitherway, great job Simon.

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 & DSL's

Thu, 07 Aug 2008 22:36:04 GMT

I was having think about fluent language interfaces and got me thinking about a DSL for search. Take this example

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);

WPF: How to stretch columns in a ListView

Sun, 13 Apr 2008 21:21:11 GMT

The ListView control in WPF is a powerful option when trying to present tabular data to users. It supports many of the common behaviours found in grid controls as well as the full WFP templating architecture we have all come to love. Below is a simple of example of a ListView which has been bound to a collection of strings. The example uses a template GridVewColumn and a 3 standard GridViewColumn’s to display the data.

And here is the associated XAML.

<Window x:Class="WPFSamples.ListViewDemo"

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

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

   xmlns:s="clr-namespace:System;assembly=mscorlib"

   xmlns:Extensions="clr-namespace:Demo.Extension.Properties"

   Title="ListViewDemo" Height="353" Width="714">

    <Grid>

        <Grid.Resources>



            <x:Array Type="{x:Type s:String}" x:Key="ourData">

                <s:String>Scott Gus:String>

                <s:String>Tim Sneaths:String>

                <s:String>Rockford Lhotkas:String>

                <s:String>Robert Scobles:String>

                <s:String>Ayende Rahiens:String>

            x:Array>

        Grid.Resources>



        <ListView Name="myListView"

                 Background="LightBlue"

                 ItemsSource="{StaticResource ourData}">

            <ListView.View>

                <GridView>



                    <GridViewColumn Header="Names" >

                        <GridViewColumn.CellTemplate>

                            <DataTemplate>

                                <Border>

                                    <TextBlock Text="{Binding .}"

                                              Foreground="Black"

                                               FontWeight="Bold" />

                                Border>

                            DataTemplate>

                        GridViewColumn.CellTemplate>

                    GridViewColumn>



                    <GridViewColumn Header="Length"

                                   Width="50" DisplayMemberBinding="{Binding Length}" />

                    <GridViewColumn Header="Names" DisplayMemberBinding="{Binding}" />

                    <GridViewColumn Header="Length"

                                   Width="50" DisplayMemberBinding="{Binding Length}" />

                GridView>

            ListView.View>

        ListView>

    Grid>

Window>

As you can see, I have highlighted the column’s in our GridView that have explicit width settings. Now looking at what we get when we run this sample you can see that the default behaviour of the GridViewColumn is to set the width to AUTO thus fitting the content being displayed. However, there often situations where you would rather the GridViewColum’s stretch to fit the remaining available space of its container. To achieve this you would imagine you could set the width of the GridViewColumn to “*”. Unfortunately this is not supported and you will be prompted with the following message.

<GridViewColumn Header="Names" Width="*">

    <GridViewColumn.CellTemplate>

        <DataTemplate>

            <Border>

                <TextBlock Text="{Binding .}"

                          Foreground="Black"

                          FontWeight="Bold" />

            Border>

        DataTemplate>

    GridViewColumn.CellTemplate>

GridViewColumn>

Cannot convert string '*' in attribute 'Width' to object of type 'System.Double'. '*'

I find this inconsistent use of the * in WPF frustrating, I am sure the WPF team have a valid reason for why this is not supported but it just feels like it should be. As the * is not supported on a GridViewColumn’s width I tried many other way to get our GridViewColumn to stretch, all to no avail.

<ListView HorizontalAlignment="Stretch" ... Makes no difference.

<ListView HorizontalContentAlignment="Stretch" ... Makes no difference.

<GridViewColumn HorizontalAlignment="Stretch" ... Not supported.

<GridViewColumn HorizontalContentAlignment="Stretch" ... Not supported.

Having played around for a while and running a few google searches it became apparent that a number of people have come across this issue, particularly when trying to stretch the last column to the remaining space. As a result, I decided to solve the problem using the attached property approach. This provides a simple way if implementing the stretch column behaviour on ListView’s. As I will outline, you change the default behaviour of the GridView setting the width to Auto so that be default all columns will stretch. Below is the XAML that will allow us to do just that.

<ListView Name="myListView"

         Background="LightBlue"

         ItemsSource="{StaticResource ourData}"

         Extensions:ListViewColumns.Stretch="true">

For us to achieve this level of simplicity in our XAML we have to place the complexity elsewhere.....in our attached property infact. The first stage when creating a new WPF attached property is to put the appropriate infrastructure in place. You will find may examples of how to create attached properties in WPF so I won’t bore you with the details here. Below is base code for our attached property.

using System;

using System.Collections.Generic;

using System.Windows;

using System.Windows.Controls;

using System.Windows.Media;

namespace Demo.Extension.Properties

{

    ///

    /// ListViewColumnStretch

    ///

    public class ListViewColumns : DependencyObject

    {

        ///

        /// IsStretched Dependancy property which can be attached to gridview columns.

        ///

        public static readonly DependencyProperty StretchProperty =

            DependencyProperty.RegisterAttached("Stretch",

            typeof(bool),

            typeof(ListViewColumns),

            new UIPropertyMetadata(true,null,OnCoerceStretch));

        ///

        /// Gets the stretch.

        ///

        /// The obj.

        ///

        public static bool GetStretch(DependencyObject obj)

        {

            return (bool)obj.GetValue(StretchProperty);

        }

        ///

        /// Sets the stretch.

        ///

        /// The obj.

        /// if set to true [value].

        public static void SetStretch(DependencyObject obj, bool value)

        {

            obj.SetValue(StretchProperty, value);

        }

       ///

        /// Called when [coerce stretch].

        ///

        ///If this callback seems unfamilar then please read

        /// the great blog post by Paul jackson found here.

        /// http://compilewith.net/2007/08/wpf-dependency-properties.html

        /// The source.

        /// The value.

        ///

        public static object OnCoerceStretch(DependencyObject source, object value)

        {

            ListView lv = (source as ListView);

            //Ensure we dont have an invalid dependancy object of type ListView.

            if (lv == null)

                throw new ArgumentException("This property may only be used on ListViews");

            //Setup our event handlers for this list view.

            lv.Loaded += new RoutedEventHandler(lv_Loaded);

            lv.SizeChanged += new SizeChangedEventHandler(lv_SizeChanged);

            return value;

        }

    }

}

Firstly, notice that dependency property inherits from DependencyObject, just about most elements in WPF derive from this type and attached properties are no exception. The remainder of the code above is fairly self explanatory, we have WPF setters and getters and we have registered the property name (DependencyProperty.RegisterAttached("Stretch") as part of this work. The only part that may not be recognised is the static method OnCoerceStretch. This method is actually just a callback that will be called prior to our property being set. It allows us to intercept the setter in order to change the the state of the value if so require.

public static object OnCoerceStretch(DependencyObject source, object value)

{

    ListView lv = (source as ListView);

    //Ensure we dont have an invalid dependancy object of type ListView.

    if (lv == null)

        throw new ArgumentException("This property may only be used on ListViews");

    //Setup our event handlers for this list view.

    lv.Loaded += new RoutedEventHandler(lv_Loaded);

    lv.SizeChanged += new SizeChangedEventHandler(lv_SizeChanged);

    return value;

}

In our coerce method above you can see we receive the dependency object the property has been attached to (in our case a listview) and then the value being set. The only this we really need to do in our method is to attach a couple of event handlers which will notify us later on about state changes in our listview.

    //Setup our event handlers for this list view.

    lv.Loaded += new RoutedEventHandler(lv_Loaded);

    lv.SizeChanged += new SizeChangedEventHandler(lv_SizeChanged);

The loaded handler is setup as we can only gain access to our listview’s internal GridView and columns once the listview has fully loaded. The SizeChanged event handler will be used to monitor when the ListView’s sizes changes, when this happens we want to be able to perform a calculation so that columns with no width having been set can stretch to fill the available space. Implementing the dependency property above allows us to use the following XAML syntax. Extensions:ListViewColumns.Stretch="true". Don’t forget to import the namespace into your XAML like this xmlns:Extensions="clr-namespace:Demo.Extension.Properties".

Back to our dependency property, the event handlers are once again fairly self explanatory, each event handler calls into a method called SetColumnWidths. As the SizeChanged event is called prior to the loaded event a simple check is made to ensure SetColumnWidths is not called at this point.

///

/// Handles the SizeChanged event of the lv control.

///

/// The source of the event.

/// The instance containing the event data.

private static void lv_SizeChanged(object sender, SizeChangedEventArgs e)

{

    ListView lv = (sender as ListView);

    if (lv.IsLoaded)

    {

        //Set our initial widths.

        SetColumnWidths(lv);

    }

}

///

/// Handles the Loaded event of the lv control.

///

/// The source of the event.

/// The instance containing the event data.

private static void lv_Loaded(object sender, RoutedEventArgs e)

{

    ListView lv = (sender as ListView);

    //Set our initial widths.

    SetColumnWidths(lv);

}

The final part of the puzzle is too look at our method SetColumnsWidth. This method does the majority of the work in our dependency property, it identifies columns in our GridView which do not have a width setting and then based on the available space remaining divides to those columns. The only interesting part is that the columns identified as having no width are stored in the ListView’s TAG property for reuse later.

///

/// Sets the column widths.

///

private static void SetColumnWidths(ListView listView)

{

    //Pull the stretch columns fromt the tag property.

    List<GridViewColumn> columns = (listView.Tag as List<GridViewColumn>);

    double specifiedWidth = 0;

    GridView gridView = listView.View as GridView;

    if (gridView != null)

    {

        if (columns == null)

        {

            //Instance if its our first run.

            columns = new List<GridViewColumn>();

            // Get all columns with no width having been set.

            foreach (GridViewColumn column in gridView.Columns)

            {

                if (!(column.Width >= 0))

                    columns.Add(column);

                else specifiedWidth += column.ActualWidth;

            }

        }

        else

        {

            // Get all columns with no width having been set.

            foreach (GridViewColumn column in gridView.Columns)

                if (!columns.Contains(column))

                    specifiedWidth += column.ActualWidth;

        }

        // Allocate remaining space equally.

        foreach (GridViewColumn column in columns)

        {

            double newWidth = (listView.ActualWidth - specifiedWidth) / columns.Count;

            if (newWidth >= 0) column.Width = newWidth - 10;

        }

        //Store the columns in the TAG property for later use.

        listView.Tag = columns;

    }

}

And that’s pretty much it..... were done! If we run the sample now it will look like this. You can see the two [Name] columns are stretching to fill the available space.

Sourcecode for this blog can be downloaded here.

Silverlight Control Skins

Tue, 08 Apr 2008 19:09:40 GMT

Corrina Barber has a great post about her new Silverlight controls skins which provide a pencil drawn visual style for the common controls.

Click to see live demo

Its great to see these kinda resources being available online. It showns the power of the WPF templating model and makes us think differently about how user interfaces can be delivered. V cool.

New look and feel for OnTheBlog.net

Tue, 08 Apr 2008 10:56:54 GMT

You may have noticed that the look of my site has changed a little. I kept getting comments that it was a little too white so i decided to jig it around a bit. As DNN implements a superb skinning architecture it was very easy to do.

If you would like to see what the site used to look like you can click here.

Old skin

Silverlight and Flex trends

Sat, 05 Apr 2008 16:19:48 GMT

I love playing with Google trends, today as a thought I decided to pop in a the following comparison for Flex and Silverlight. Not much between them at the moment it seems.

C# Binary Search

Mon, 07 Apr 2008 12:50:37 GMT

A binary search is an algorithm is able to find a specific value within a sorted array by making increasingly acurate guesses based on a comparision result. I was discussing this with a friend at work the other day and thought I would put one together in C# for illustrative purposes.

First we need to create the array with random data and then sort this array. I decided that using guids would provide a good level of random data for our test. I therefore create a million guids in my array then sort it. This is shown below.

        ///

        /// Mains the specified args.

        ///

        /// The args.

        static void Main(string[] args)

        {

            //Setup random data.

            List<String> RandomItems = new List<string>();

            for (int i = 0; i < 1000000; i++){RandomItems.Add(Guid.NewGuid().ToString());}

            //Get search item and sort.

            string searchFor = RandomItems[345];

            RandomItems.Sort();

            Console.WriteLine("Press enter to run test");

            Console.ReadLine();

         }

Next I created the algorithm which would quickly narrow down on the value we are searching for. There are 3 things to remember when it comes to binary searches.

Find the median of a particular range within your array.

Compare the value at that midpoint to see if ths greaterthan, lessthan or Equal.

Call the same method recursively in order to narrow the search.

The Binary search class is shown below.

        ///

        /// Finds the index. (Public Overload.)

        ///

        ///

        /// The sorted list.

        /// The search criteria.

        ///The index of the specified item.

        public static int FindIndex(List<String> sortedList,string searchCriteria)

        {

            return FindIndex(sortedList, searchCriteria, 0,sortedList.Count);

        }

        ///

        /// Finds the index.

        ///

        /// The sorted list.

        /// The search criteria.

        /// The startposition.

        ///The index of the specified

        private static int FindIndex(List<string> sortedList,string searchCriteria, int startPosition, int endPosition)

        {

            int lastPos = startPosition;

            int range = (endPosition - startPosition);

            if (range == 0) return 0;

            int midPoint = (range / 2) + startPosition;

            int equality = sortedList[midPoint].CompareTo(searchCriteria);

            Console.WriteLine(midPoint);

            //Equals

            if (equality == 0)

                return midPoint;

            //Greater than

            if (equality == -1)

                return FindIndex(sortedList, searchCriteria, midPoint, endPosition);

            //Less than

            if (equality == 1)

                return FindIndex(sortedList, searchCriteria, lastPos, midPoint);

            return -1;



        }

Finally, I want to run the algorithm and work out the cost of finding my value within a million strings. So we need to add the following to our static main.

//Run our binary search.

DateTime start = DateTime.Now;

Console.WriteLine("Item found at position [" + BinarySearch.FindIndex(RandomItems, searchFor).ToString() + "]");

DateTime end = DateTime.Now;

Console.WriteLine("Cost M/s: " + new TimeSpan(end.Ticks - start.Ticks).TotalMilliseconds.ToString());

Console.ReadLine();

The results of running this algorithm are shown here.

Press enter to run test

500000
250000
375000
312500
343750
328125
335937
332031
330078
329101
329589
329833
329955
330016
329985
330000
330008
330012
330014
330013
Item found at position [330013]
Cost M/s: 5

Macbook Pro and Vista

Wed, 02 Apr 2008 12:51:45 GMT

I recently updated my laptop to a Macbook Pro 2.6Ghz Intel Core 2 Duo with 4gb of ram with the 200gb 7200rpm disk. I have created a windows partition on the machine and installed vista, Visual Studio 2008, SQL Server 2005, Office 2007 etc etc.

Anyways, Just wanted to express that this machine is blisteringly fast! My performance score is shown below.

Decompiling Silverlight Apps

Sat, 29 Mar 2008 20:48:08 GMT

Did you know you can decompile Silverlight apps? As with ever other .NET app, if you have the assemblies you can pretty much load them into reflector and view the source.

So when it comes to silverlight how do you get the assemblies in the first place? Well it turns out when you develop your app all the assemblies are packages into a XAP file which is then downloaded to the client.

An XAP is actually just a zip file with a different extension. Therefore, all you need to do is the following.

1.) Locate the XAP file on a web page or file system by looking at the source.

2.) Place into the browser and download the XAP package.

3.) Once downloaded, change the XAP extension to .ZIP

4.) Extract the package using whichever tool you like. I use WINRAR.

5.) Locate the assemblies in reflector and view the source.

Linq Gotcha: Deferred Queries

Sat, 05 Apr 2008 16:05:02 GMT

In Linq there are two kinds of queries you can execute on objects. Deferred and Non-Deferred. As expected, non-deferred queries will be executed immediately, deferred queries on the other hand will not be executed until iterate over the collection.



With that in mind take the following query

            string[] servers = { "Server 1", "Server 2", "Dave" };

            IEnumerable<string> results = servers.Where(server => Char.IsDigit(server[7]));

In this query we want to bring back the first two elements in our array which have a number at the 7^th index, therefore we would get two results returned. However, although this code compiles, we have actually created a situation whereby a System.IndexOutOfRange exception will be thrown whenever this query is executed, this is because the server name Dave is only 4 chars long.   This should be easy to find if we start using our results collection directly below our query but this may not always be the case. We may do the following.

            string[] servers = { "Server 1", "Server 2", "Dave" };

            IEnumerable<string> results = servers.Where(server => Char.IsDigit(server[7]));

                                ConnectToServer(results);

Our ConnectToServer method

                public void ConnectToServer(IEnumerable<String> servers)

      {

            if(servers.Count > 0)

                //Do Something

      }

In this scenario, out System.IndexOutOfRange exception will be thrown from within the ConnectToServer method which may not have changed in years.  By using linq are we possibly making it very difficult for ourselves when trying to track down errors?

Multiple Browser Compatibility

Mon, 24 Mar 2008 17:40:49 GMT

Rockford has an interesting post about a website called http://browsershots.org. The idea is, you submit a url and they will check how your website renders in 45+ browsers on multiple operating systems and provide screenshots for you to download. They also do some cool javascript testing as well.

Below is an a screenshot of the initial results page for the home page of my site.

And here is what my site looks like in Opera running on linux. V.cool.

WPF Easter Egg

Mon, 24 Mar 2008 09:47:02 GMT

Ok I'm sure you were hoping I was going to announce something cool like the hidden flight simulator in excel.

Sorry, here is some XAML instead.

Windowless Easter Egg

<Window x:Class="WindowlessForms.Window1"

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

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

   Title="Window1" Height="400" Width="600" WindowStyle="None"

       AllowsTransparency="True" Background="Transparent" WindowStartupLocation="CenterScreen">

    <Border>

        <Ellipse Stroke="Black">

            <Ellipse.Fill>

                <RadialGradientBrush GradientOrigin="0,0.4" Center="0,0.5" RadiusX="1" RadiusY="2">

                    <RadialGradientBrush.GradientStops>

                        <GradientStop Color="AliceBlue" Offset="0"/>

                        <GradientStop Color="Blue" Offset="0.1" />

                        <GradientStop Color="AliceBlue" Offset="0.2" />

                        <GradientStop Color="blue" Offset="0.3" />

                        <GradientStop Color="AliceBlue" Offset="0.4" />

                        <GradientStop Color="Blue" Offset="0.5" />

                        <GradientStop Color="AliceBlue" Offset="0.6" />

                        <GradientStop Color="blue" Offset="0.7" />

                        <GradientStop Color="AliceBlue" Offset="0.8" />

                        <GradientStop Color="blue" Offset="0.9" />

                        <GradientStop Color="AliceBlue" Offset="1" />

                    RadialGradientBrush.GradientStops>

                RadialGradientBrush>

            Ellipse.Fill>

        Ellipse>

    Border>

>

Robotics gone wrong

Thu, 20 Mar 2008 20:42:05 GMT

Something has definately gone wrong here.... A quick browse for robots on the web turns up a robot trying to be human and a human trying to be a robot.

Robot Albert Hubo

Robot Dance

Web 3.0 and search engines

Thu, 20 Mar 2008 10:01:31 GMT

Take the following statement.

Googlebot processes each of the pages it crawls in order to compile a massive index of all the words it sees and their location on each page. In addition, we process information included in key content tags and attributes, such as Title tags and ALT attributes. Googlebot can process many, but not all, content types. For example, we cannot process the content of most Flash files or dynamic pages.

You can find this text in the google indexing FAQ site here. What I find compelling about this statement is that of the last line..

we cannot process the content of most Flash files or dynamic pages.

This raises an interesting question with regard to the future of search engines as we enter the web 3.0 era. As HTML has slowely reached the limits of what it can offer, we are starting to see the rise of new rich/smart client style applications based on technolgies such as silverlight, Flex and Flash.

Tim Berners-Lee has predicted that web 3.0 could possibly be based on vector graphics platforms. These technologies offer rich vector graphics with runtime libraires that are delivered direct to the desktop. With these runtimes comes the use of custom binary formats that allow code to be run within the browser and peform functions that standard HTML/Ajax apps would dream of.

So with the winds of change coming....how will search engines continue to perform effective indexing of site content when its delivered in custom binary formats?

Will we see new standards defined that will be specifically used for the publication & management of site content for indexing?

Will search engines implement new techniques for indexing binary files?

Will our Web 3.0 apps always require HTML equivalents for supporting search providers?

I dont know the answers to these questions yet but I am looking forward to seeing how it pans out.

User Agents for February

Wed, 19 Mar 2008 19:28:58 GMT

Looking through my logs I decided to compose a list of useragents/browsers visiting my site during feb. I was amazed to see that there were still people using IE2 out there! I mean.... really???

These results are shown below.

Netscape Navigator 6+
Internet Explorer
Internet Explorer 6
Netscape Navigator 4
Internet Explorer 5
Internet Explorer 4
WebAlta Crawler/2.0 (http://www.webalta.net/ru/about_webmaster.html) (Windows; U; Windows NT 5.1; ru-RU)
MSNBOT
msnbot/1.1 (+http://search.msn.com/msnbot.htm)
Internet Explorer 2
Feedfetcher-Google; (+http://www.google.com/feedfetcher.html; 3 subscribers; feed-id=10707310861055891819)
Feedfetcher-Google; (+http://www.google.com/feedfetcher.html; 2 subscribers; feed-id=10707310861055891819)
ia_archiver
Netscape Navigator 3
BlogPulse (ISSpider-3.0)
BlogPulseLive (support@blogpulse.com)
EnaBot/1.2 (http://www.enaball.com/crawler.html)
freedir.co.uk/0.8 (+http://freedir.co.uk/directory/)
Opera/8.00 (Windows NT 5.1; U; en)
NewsGatorOnline/2.0 (http://www.newsgator.com; 1 subscribers)
Opera/9.0 (Windows NT 5.1; U; en)
Opera/9.00 (Windows NT 5.1; U; en)
Opera/9.26 (Windows NT 6.0; U; en)
psbot/0.1 (+http://www.picsearch.com/bot.html)
SurveyBot/2.3 (Whois Source)
Technoratibot/0.7
Tgulhz enqb iwgovpdqc
Wkivtc bnfswe wvdu
Pxmtonqhj szftv djhiesuc
Opera/9.50 (Windows NT 5.0; U; pt-br)
Opera/9.00 (Windows NT 5.1; U; ru)
Opera/9.23 (Windows NT 5.1; U; en)
Opera/9.24 (Windows NT 5.1; U; en)
Opera/9.26 (Windows NT 5.1; U; cs)
Opera/7.50 (X11; Linux i686; U) [en]
Opera/8.0 (Macintosh; PPC Mac OS X; U; en)
Opera/8.01 (Windows NT 5.1)
Internet Explorer 3
Ajuqwt tdmy djrpagf
Java/1.6.0_02
Jyxgil mryhla ugxwa
Lwizpcxo mgvx lsxa

FUN: Easters coming

Mon, 17 Mar 2008 20:50:07 GMT

Looking through my emails I found a few easter related jokes bouncing around. This one particulary made me laugh so thought I would share.

Silverlight 2 Control Template Browser Source Code

Mon, 17 Mar 2008 20:30:07 GMT

Just been snowboarding in Austria for the last few days. Had some great snow and a litte stiff today. I just wanted to blog quickly to tell you that you can now download the source code for the Silverlight 2 Control Template browser. Please note, this version currently uses an embedded XML file to render each template. I am working on updating this to use a XAMLWriter implementation but this is still a work in progress.

Download

Silverlight 2 Control Template Browser

Mon, 09 Jun 2008 20:36:37 GMT

After a fairly hectic week I finally had a chance to sit down and have a play with the new Silverlight 2 beta 1 release. I have been waiting a long time for this release as it finally provides Silverlight with some of the key features that have made WPF such a compelling framework to work with.

In order to get to grips with these features, I decided that I would write a simple control template browser that users can access over the web. Control Templates are the default look and feel that are implemented by Silverlight controls. The template browser allows you to choose a control from the side menu and will display the control template in the right had pane. Building this kind of tool is useful for a number of reasons, firstly I hadn’t seen a zero-install implementation and secondly it provides just enough scope for me to assess the new features available. Below is a summary of the areas I have tested as part of this tool.

The new control libraries.

New flow layout containers such as Grid, StackPanel and Borders.

Overriding of control templates

Defining styles in the resources section

Databinding of styles

Data templates & business object bindings

.NET Framework support

In writing the control template browser I found that the designer support in visual studio worked well. I would randomly get some error about not being able to attach to the browser process but this was fixed with a quick restart of VS2008.

The controls available as part of Silverlight 2 have the majority of the most commonly used properties, now and then however you will find holes in this which may make you scratch your head. Generally though I think the team have done a good job. Just one note on controls... there is no ComboBox...Why? Also I couldn’t get the textbox scrollbars to display.

I did find a rather frustrating issue with the fact that I could not use the MergeDictionary class in my XAML to import styles from other resource files. The result is that I had to declare all my styles in the resources at the top of my page.

Other than these few niggles which have work arounds, I reckon future of Silverlight look bright. I intend to test the network support in Silverlight in a future blog. But I have snowboarding to do before then!

Links
Source Code
View Silverlight Control Template Browser
Known Issue: Template not loading for TextBox Control

Silverlight on the go.... Nokia gets the Jump

Tue, 04 Mar 2008 12:50:50 GMT

Well it seems one of the big annoucments that was due to be made at Mix 08 is that Silverlight is coming to mobile devices and more importantly... Nokia handsets.

There is apparently going to be a demo of an S60 device running Silverlight mobile edition which I can wait to see! Will post more when it arrives!

The Nokia s60

WPF: Extending the Page & UserControl base classes

Mon, 25 Feb 2008 22:50:15 GMT

When working with different .NET technologies it is often good practice to extend a number of bases classes for your own requirements. There are couple of benefits for doing this.

The derived classes provide a layer of protection/abstraction from the core framework so that changes can be managed more effectively.

The derived classes provide the ability for you to extend base behaviour and share that throughout your application.

You can increase testability.

Generally, when starting a new development, I like to do some of this infrastructure work upfront, this saves me a lot of refactoring down the line when I realise I need to extend a base class. Following this approach is particularly useful when working with .NET UI technologies such as WinForms, ASP.NET and WPF which implement a number of base classes upon which the majority of UI components are based.

Below is an example of the standard WinForms model whereby each Form is derived from System.Windows.Forms.Form versus the model I implement when I intend to extend the base Form class.

FormEx implementation

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Windows.Forms;

namespace Extended.Base.Example

{

    public class FormEx: Form

    {

    }

}

Our StandardForm implementation

using System;

using System.Collections.Generic;

using System.ComponentModel;

using System.Data;

using System.Drawing;

using System.Linq;

using System.Text;

using System.Windows.Forms;

namespace Extended.Base.Example

{

    public partial class StandardForm : FormEx

    {

        public StandardForm()

        {

            InitializeComponent();

        }

    }

}

All this works fine and you can compile and run the application. WinForms will not care if we have extended System.Windows.Forms as long as we still have the class in our inheritance hierarchy and it adheres to the same contract.

Now I am currently working on a WPF XBAP application and I want to use the same pattern within the world of WPF. You would imagine that this should be a fairly simple task. Each Page derives from System.Windows.Control.Page and User controls derived from System.Windows.Controls.UserControl. Therefore, it would seem logical that all that is required is to create a number of new classes that inherit the appropriate base class and then allow our new pages/controls to inherit from these. Below is some simple code to reflect this approach in an XBAP.

Our new derived Page Class

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Windows.Controls;

namespace Demo

{

    public class PageEx: Page

    {

    }

}

A XAML page inheriting our extended class.

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Windows;

using System.Windows.Controls;

using System.Windows.Data;

using System.Windows.Documents;

using System.Windows.Input;

using System.Windows.Media;

using System.Windows.Media.Imaging;

using System.Windows.Navigation;

using System.Windows.Shapes;

namespace Demo

{

    ///

    /// Interaction logic for Page1.xaml

    ///

    public partial class Page1 : PageEx

    {

        public Page1()

        {

            InitializeComponent();

        }

    }

}

And the XAML for our Page

<Page x:Class="Demo.Page1"

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

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

   Title="Page1">

    <Grid>



    Grid>

Page>

All we should need to do now is compile and run our application. If we do this, we notice that it’s not going to be as simple as we thought. Below is an error displayed from Visual Studio 2008.

The “Partial declarations of 'Your Type' must not specify different base classes” message is a standard compiler message that you can get whenever you implement a class using partial class files and then forget to may sure they all derive from the same base class. At first this error message seems a little odd as you only have one class in your solution window and that’s correctly deriving from PageEx.

The reason you encounter this error is due to the fact that WPF pages and controls have an auto generated file which is created by the compiler. This code is used for initialising the XAML document as some other gubbings. Therefore we need to update this file to ensure it reflects our new base class. If you want to see this class all you need to do is place the cursor on the InitializeComponent, right click and then choose “Goto Definition”. Doing this will be present you with the following.

View

So now we can see where our problem is, we can update the generated file to the following.

    public partial class Page1 : PageEx, System.Windows.Markup.IComponentConnector

If you go about running the application the application runs with no problems. But this is not the end of the story. After working elsewhere in your application you may find that all of sudden the issue of partial classes returns. Looking at the generated file you will notice that it has regressed back to inheriting from System.Windows.Controls.Page.

When I first encountered this I scratched my head for a little and performed a few google searches. I eventually found that the problem was not related to generated file but that my XAML also needed to amended to reflect the extended base class. Below is the updated XAML file which shows my new XAML.

<local:PageEx x:Class="Demo.Page1"

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

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

   xmlns:local="clr-namespace:Demo"

   Title="Page1">

    <Grid>



    Grid>

local:PageEx>

The first step is to import the namespace where your extended Page class resides.

xmlns:local="clr-namespace:Demo"

Then we need to update our Pages opening and closing tags to reflect the new type using the namespace alias we defined. In this case called local

<local:PageEx x:Class="Demo.Page1"

Now if you run the application you will no longer receive the “Partial Class” error and you can get onto the fun stuff! You will also need to use the same approach if you plan to extend other WPF base classes.



WPF Ribbonbar and more coming in 2008!

Thu, 21 Feb 2008 12:32:42 GMT

Scott Gu has shed some light on some of the changes coming to WPF this year. Notably, Scott inidcates that there will be new contols for WPF, one of which is a new a "Ribbon" control. I have thought that for a while that Microsoft needed to get this control to market as the Office 2007 styling has become quite popular.

There are a number of vendors that do offer a WPF ribbon these are shown below.

Divelements - Sandock Ribbon (Xbap demo)

DotNetBar Ribbon

Actipro (Xbap demo)

Also it seems more graphic intensive features such as shadowing etc are being pushed onto the graphics hardware increasing performance. V.cool!

Silverlight 2.0! Cant wait!

Mon, 18 Feb 2008 13:44:39 GMT

I have just finished listening to Scott Gu's comments on Silverlight 2.0. From what he is saying 2.0 should finally offer the level of functionality to truly make Silverlight a compelling option.

Just to summarise....Silverlight 2.0 will get the following.

Large suite of controls for developing LOB style applications

Databinding support

Styling and control templating

Flowlayout support

WCF Communications stack support

Good news!

Alt.NET Seattle

Fri, 15 Feb 2008 10:24:49 GMT

Having attended the Alt.net UK conference a few weeks ago I am disappointed by the fact that I cannot make the US event. There's going to be some great people there and the chance to discuss topics with them would have been great.

I am making sense of my decision using the following.

Its expensive to head over to the US just for a conference.

I am getting married this year and need to save some money.

The "Mrs" gets jealous and thinks its a holiday.

There will be other events.

With that I rest my case.

Random muttering: Visualising Test Coverage

Mon, 18 Feb 2008 19:56:16 GMT

Ok, this one will is going to sound a little odd but bare with me. The other day I received a call from a friend who I used to work with. He’s now moved on to a new company and is responsible for managing a team of developers who have been focused on developing internal systems.

Upon starting with the company, the IT director had expressed his concerns that the development teams were generally gun ho about configuration management and that on many occasions critical systems had been down for extended periods. Basically, my friends role is to get a grip with these kind of issues and improve the overall quality and professionalism of the team.

He told me that the systems had been written in .net 1.1 and very little progress had been in terms of migrating them to 2.0 and definately no 3.5. Another key issue he had identified was that the application had absolutely no code coverage and therefore developers were unaware of what impact their changes could have to the behaviour of the applications. I think more to the point, as we discussed the environment, it became apparent that the majority of developers had very little understanding TDD and the benefits it can bring to your project.

Given the environment, my friend and I discussed a number of options that he could take forward in terms of educating the team in the ways of TDD and primarily some way of obtaining some level of test coverage of the application code. It was the later thread that sparked an interesting conversation about conceptualising a test and how you can get increase coverage from a small number of tests. He had explained that the architecture was fairly standard with a complex model that uses fine-grained interfaces for business entities wrapped up with a coarse-grained interface that is exposed to the UI.

Discussing the split between UI code and service/business code it seemed there was approximately 30/70 split. Therefore, we both felt the best place to start would be at the service contract layer. The service contract provides a single point of access into a complex system. This is a very key point, what it essentially means is that by using the service contract and multiple data scenarios we can cover large portions of code within the complex model. To help developers visualise this concept, we talked through a few analogies that would fit. Below are 3 visualisations of this.

Lightning Forks

Ants nest paths

Tree root system

As you can see, each of these images can be used to visualise the many branches of code that could possibly be taken from the top down entry point. Exploring these different paths takes a multitude of data scenarios. Each data scenario being passed into the top level entry point results in decisions being made on that data at each possible branch. Therefore theoretically, albeit unlikely, you could write 1 test for an service contract method that could be re-run many many times with different inputs and attain 100% coverage of the branches below.   Validating key state data on exit of these test runs can help enforce the behaviour of the system and identify issues that may arise from developers not being able to see the impact of their changes.  Its not ideal, but it is an option.

Human’s by nature react well to the visualisation of abstract concepts, it helps us comprehend complex intangible systems that other species have (so far) failed to master. They say a picture says a thousand words, I am thinking it could be a lot more.

In the case of the applications my friend needs to maintain, where no tests currently exist, this approach provides a valuable step in the right direction. It helps educate the developers who have not had to worry about testing before, as well as the additional advantage of moving towards building important quality checks within the applications. I am planning to catch up with my friend for beers in a few weeks time so I will update you to see how he is getting on.

NHibernate and Tight Coupling

Wed, 05 Nov 2008 10:59:15 GMT

So, I'm half way through the week and had a chance to reflect on all the information I absorbed at the UK Alt.net conference last weekend. There were 4 sessions I attended during the day and the 3^rd session was titled “NHibernate, Linq and ORM”. Out of all the sessions I attended, this was probably the largest. The majority of attendees of this session were NHibernate advocates. For me, when it comes to NHibernate the jury is still out, the following article describes one of the reasons why.

Some Background

Just to give you some background, I have been using NHibernate in-depth on a project for the last 9 months. I am no expert in the field but no novice either. Before using and ORM tool, I would write stored procedures in order to access crud functions of the database. Actually, “writing stored procedures” is overstretching, I would use codegen tools, run them over the database and plug my code into the resulting assembly. This was cool for a number of reasons, firstly the output assembly would show any changes or conflicts in code at compile time, and secondly it defined an explicit contract with my data store. I’m big on scaffolding in code (I know its not 100% TDD) but it provides a great way to visualise your overall code architecture.

When I started working on the project, I had very little exposure to ORM tools. I had read blog posts & articles but had never really cut my teeth on the technology. I would say that in the .net world, NHibernate is probably the no 1 ORM tool available. NHibernate is a port of the java implementation Hibernate which has been popular for many years.

The thinking behind ORM tools is that they “become the database” and that you really don’t need to waste time writing SQL anymore. I have to say, the moment I started reading about ORM tools I felt a little uneasy. SQL is a language I am very comfortable with, more to the point it has been specifically developed in order to query data in a mathematical and consistent way. The idea of not touching SQL and focusing purely in code seemed a little frightening to me. Trying to put my fears aside, I joined the project and jumped two feet into NHibernate.

The Learning Curve

Now during the last 9 months I can honestly say that the NHibernate learning curve can be a little erratic. Initially the model seems simple with a mapping file connecting your entities to the database. But as you continue, issues such as inheritance, polymorphism & lazy loading all start to impact your productivity. Now let me make it clear, all those issues can be solved with NHibernate in an elegant way, however finding that way takes time. One of the biggest problems I faced was an issue with entities that did not require to be saved. See the model below.

In this model we have all objects connected in a parent-child fashion. In this case the selected class which does not have a related database table, controls access into our complex system. This posed a bit of an issue for me as Nhibernate infers saving via a mapping file and in this case the selected class does not exist in the parent mapping file. Therefore, I felt I had run into an Object/Relational Impedance mismatch. Again, it was just my understanding of NHibernate, I soon found that I could solve this problem using NHibernate Components. So as you can tell, NHibernate is a large beast and it issues such as these that can really throw a spanner in your productivity. But they are not issues that cannot be resolved.

NHibernate’s inherent Tight coupling

As my confidence with NHibernate has grown, I have felt that most issues can be resolved, all you need is the knowledge. However, there is one issue that I feel NHibernate creates that cannot be resolved. As I mentioned previously, I used to use stored procedures to interact with my database. Stored procedures in my mind are great as they enforce a contract between application code and the database.

Recently however, I hear people at conferences make snide remarks about them, like they are some form of pollution in the their code. I find this reaction strange, everywhere else in our code we spend time make sure there are adequate layers in order to reduce complexity and shield us from breaking changes. So why is it that I hear people turning their nose up at sprocs? The answer lies in the history of sprocs, I think many of us have experienced sprocs that may be 100’s or 1000’s of lines of code. These procedures are in essence business logic, it’s this bad habit that has forced us to abandon them. A decision I feel is incorrect.

What stored procedures really are are “service contracts”, regardless of bad practices implemented by devs or dba's in the past, they still serve a purpose in that they decouple the database schema from our application code. Its this important fact that I believe NHibernate misses and as a result leads to tight coupling between application code and the database schema. (Please note: I know NHibernate can use stored procs instead but I question the value NHibernate offers over codegen in the same situation).

Lets take a simple mapping file for an address entity (shown below)

In this mapping file, we can see that properties on our entity map directly to database columns. This is the most common pattern used by developers working with NHibernate. Now let’s jump forward.. say 6 months after our application has gone to production, I am a DBA and I need to restructure the Address table as new services are consuming that data or execution plans are bringing the server to a halt. I want to rename columns and move the notes field into a separate table specifically designed for notes data. I can do this via simple script, however what I do not realise (being the dba) is that I have an application that is tighly coupled to the address table. I have an issue where changing the database could break any number of applications that depend on the data. I just don’t know!! More importantly, the developers who wrote the application are no longer around (written by a supplier perhaps). I don’t even know about the dependency FULLSTOP as I cannot see these application server that may sit in disparate regions. What we have effectively done is create a long dependancy & support issue for our applications.

We could look to resolve this issue by implementing our mapping file so that it points to a view rather than the table, this however will only go so far, updates and deletes may need to span many tables which will be impossible to implement via view.

So what do we do?

The answer is not clear, NHibernate & other ORM tools rely on mapping properties to database columns. This pattern results in tight coupling that makes applications suffer from a poor resistance to change. We as developers cannot assume that the database is just for the application we are developing, data is a commodity and therefore commonly shared amongst multiple services, and the querying of that data may be good for one scenario but not the other.

Its seems ORM’s fall right into this hole, they offer us productivty but at a cost. As I said, the jury is still out for me as to whether the pro's out weight the cons but being aware is vitally important.

I have a number of other issues I have comne across since using ORM's and I will be looking to blog about these in the future.

Visual Studio Xmas tree settings

Fri, 08 Feb 2008 15:55:53 GMT

Most developers spend the majority of their day with their head stuck inside visual studio, I’m no different, so as a result I like to customize my editor so that I am as comfortable as possible. Its in this area i’m a little old fashioned. I can’t stand the default white colour settings that visual studio offers, therefore I spend quite some time tuning them so they meet my needs. Below is an example my code windows in visual studio. I really like these settings and I feel it makes the code far more readable and items such as strings, numbers, operators, keywords and regions are all specifically coded.

Many of my colleagues have commented that my settings make my code window look like a Christmas tree. So if your feeling like you want to be a little festive then you can grab them here.

Alt.Net UK Conference

Thu, 07 Feb 2008 10:57:52 GMT

As some of you may know..... and some may not, I have been working with Conchango on a project for the last 9 months. The conchango guys are great to work with, so when they asked if I wanted to attend the Alt.Net conference this weekend (as they were hosting it), I was chuffed as originally I had thought I had missed the registrations.

The conference was broken up over two days. Friday was a meet and greet session in the evening, everyone gets the opportunity to propose a session that they would like covered on the Saturday. I was really impressed with the topics that were up for discussion, my two offerings were "Declarative Programming & Testability" and "Why use ORM".

After filling the whiteboard with post it notes, I was amazed to see just how many where were related to testing and general quality of development. Having defined a rough agenda for the Saturday, everyone headed off to the Bankside bar where we could get to know each other. I couldn't stay too long as getting home takes an hour and half and had been at work all day I was a little shattered.

Over the next week I will be updating you about the sessions I attended and some of the key conclusions I came to. Generally though, I thought the conference was a great success. I got to meet some fantastic people and validate my ideas against others... oh and play a little table football. Many thanks must go to Ian Cooper, Alan Dean and Ben Hall for great organisation.

Visual Studio Ribbon Bar

Thu, 07 Feb 2008 10:56:59 GMT

Last night I awoke around 3am in a state of panic. What you ask could be making me worry? The answer is simple.....

Visual Studio implementing the Ribbon Bar

Lucky for me it was just a dream..........it was wasn't it?

Is BizTalk as a product dead?

Fri, 08 Feb 2008 15:51:18 GMT

Last weekend I was at a wedding fair with my fiancée looking at the last remaining big things we need to get sorted for our wedding in August. While there, I ran into my brother in-law (to be) who is also getting married. As he works at my old company we naturally ended up talking shop. During this time the girls were browsed for fairy dust or something. (I think it’s fair to say we aren't really there by choice. :-))

So during our discussion he told me about his boss asking him to get some Microsoft certs and he had a choice between BizTalk and SharePoint. At the time I said get the SharePoint certs as they are far more likely to get you a job in the future as SharePoint is generally more popular in the enterprise. After that I moved on and forgot about things.... until today.

As I was going for a walk during my lunch time I started to think about Microsoft’s current strategy for BizTalk and how there seems to be this awkward situation now that windows workflow has arrived. Having worked with both WF and BizTalk it is clear where the difference are between the products. I have listed these below.

1.) BizTalk is the enterprise solution and can scale (albeit costly), workflow is not currently seen this way.

2.) BizTalk comes with a set of adaptors/accelerators for EAI, workflow has WCF, but custom formats such as EDI are not backed in.

3.) BizTalk provides sophisticated BAM. Some work has been carried out to allow Workflows to integrate with BizTalk’s BAM but this can be considered just an integration point with BizTalk.

4.) BizTalk comes with productivity tool like the mapper. XSLT is still a rare skill and the mapper is not available for WF.

5.) BizTalk has a sophisticated rules engine. Workflow does not.

6.) BizTalk comes with Health and Activity monitoring.

Although there are many additional enterprise features that BizTalk has offer over WF, there is one issue and that needs to be addressed. That is, that Microsoft now has two retail workflow/orchestration engines.

Having two workflow engine technologies is just not right, and Microsoft has recognised that. As a result WF is due to be integrated into future versions of the BizTalk product. However doing so raises a number of questions around the value of BizTalk as a product on its own right. If WF provides the core orchestrations (which is really the selling point of BizTalk) then surely the other features of BizTalk are just extension to WF?

Sample design surface for WF below

I am not sure in what way Microsoft will distinguish BizTalk from WF, but my thoughts are that the product will be reduced to a set of WF extensions for the enterprise.

I just hope in the not too distant future that the BizTalk runtime/hosting service will become part of WF core services. Doing so will increase WF adoption dramatically.

Update post here!

70-502, 70-503, 70-54 Microsoft .net 3.5 Certification

Thu, 07 Feb 2008 10:56:15 GMT

So last year I updated my MCSD to the .net 2.0 certifications that included features such as generics etc. I left that update a little late in the day as I had not really had a need to update them and they felt like small extensions to the 1.1 certs I had already achieved.

Over the last year and half I have been workign with .NET 3.0 technolgies, 3.0 brings a raft of new technolgies to the developer. The 3 core technolgoy center pieces being WPF, WF and WCF.

As a result I have been eagerly awaiting the .net 3.0 exams in order to keep my certification up to date. It seems however microsoft have decided to skip by 3.0 certs and go straight to 3.5. Either way I'm happy and I will be boooking myself in in the not too distant future.

Exam 70-502 Microsoft .NET Framework 3.5 - Windows Presentation Foundation. Expected to be released in February 2008. http://www.microsoft.com/learning/exams/70-502.mspx

Exam 70-503 Microsoft .NET Framework 3.5 - Windows Communication Foundation. Expected to be released in February 2008. http://www.microsoft.com/learning/exams/70-503.mspx

Exam 70-504 Microsoft .NET Framework 3.5 - Windows Workflow Foundation. Expected to be released in March 2008. http://www.microsoft.com/learning/exams/70-504.mspx

3.5 .Net Framework Souce Release

Thu, 07 Feb 2008 10:55:06 GMT

Over the weekend I had a play with the new .NET framework source code release which now allows you to debug into framework classes as part of your standard debugging. The source gives a good insight into how classes have been built and can often help in understanding their behaviour. Also it comes with the original comments which can be quite enlightening. You can only do this from visual studio 2008 and most of the .net framework including WPF can be debugged.

Info for setting it up can be found here http://blogs.msdn.com/sburke/archive/2008/01/16/configuring-visual-studio-to-debug-net-framework-source-code.aspx

Couple of funny comments in the code that I found from initial play below.

                Optimistic developer

                    // Note: This doesn't work on Win9x. We can implement this

                    // functionality on Win9x by writing a 16 bit DLL and

                    // calling the LAN Manager method NetWkstaGetInfo(). See

                    // http://support.microsoft.com/support/kb/articles/Q155/6/98.asp

                    // We don't have the time to implement this in V1. Hopefully

                    // by the time V2 rolls around, everyone will run Windows XP.

      Hacking is part and parcel of the MS Job. J

        // HACK HACK HACK - when we change RightToLeft, we need to change the scrollbar thumb.

        // We can't do that until after the control has been created, and all the items added

        // back. This is because the system control won't know the nMin and nMax of the scroll

        // bar until the items are added. So in RightToLeftChanged, we set a flag that indicates

        // that we want to set the scroll position. In OnHandleCreated we check this flag,

        // and if set, we BeginInvoke. We have to BeginInvoke since we have to wait until the items

        // are added. We only want to do this when RightToLeft changes thus the flags

        // STATE2_HAVEINVOKED and STATE2_SETSCROLLPOS. Otherwise we would do this on each

WPF text trimming

Thu, 07 Feb 2008 10:49:52 GMT

Here’s a useful tip for you budding WPF aficionados out there. If there is any chance that the text in a textblock may become truncated (the databound text may not fit or the window may be resized), assuming you don’t want the text to wrap (where you would use the TextWrapping attribute), add the TextTrimming attribute. Your options are None (no ellipse – default), WordEllipse (an ellipse is inserted after the last word that fits) or CharacterEllipse (an ellipse is inserted after the last character that fits).

Example from MSDN

<TextBlock Name="myTextBlock" Margin="20" Background="LightGoldenrodYellow" TextTrimming="CharacterEllipse" TextWrapping="NoWrap" FontSize="14" > One<LineBreak/> two two<LineBreak/> Three Three Three<LineBreak/> four four four four<LineBreak/> Five Five Five Five Five<LineBreak/> six six six six six six<LineBreak/> Seven Seven Seven Seven Seven Seven Seven TextBlock>

Results in

Hope it helps.

WPF Bug... ListView within a Listbox

Thu, 07 Feb 2008 10:49:52 GMT

I was recently having issues with a XAML structure I was working on. The stucture of my XAML was as follows.

LISTBOX (Bound to collection of custom objects)

{Item Template}

ListView (Bound to Collection of Child Objects that hangs of the Parent binding)

Now when I ran the app I got the binding firing for each parent and associated child collection but when the xaml renders only the first listboxitem has a listview bound below it. Is this a bug in the way ListViews work when nested within a Listbox's data template?

The answer it turns out is a big YES. Apparently, this is a know issue in WPF. In order to resolve this issue you need to make sure that all your datatemplates are moved to resources. Only then will the databinging and rendering work.

My XAML is show below for reference.

Window x:Class="WpfApplication1.Window1" xmlns=http://schemas.microsoft.com/winfx/2006/xaml/presentation xmlns:x=http://schemas.microsoft.com/winfx/2006/xaml Title="Window1" Height="300" Width="300" >
<StackPanel VerticalAlignment="Stretch" >
<Button Click="Button_Click">Run TestButton>
<ListBox Name="ParentListBox" VerticalAlignment="Stretch">
<ListBox.ItemTemplate>
<DataTemplate>
<StackPanel>
<Border BorderThickness="1" BorderBrush="Black">
<StackPanel>
<TextBlock Height="25" Text="{Binding Path=ParentName}">TextBlock>
<ListView ItemsSource="{Binding Path=Children}" Margin="0" Name="SubList">
<ListView.ItemContainerStyle>
<Style TargetType="ListViewItem">
<Setter Property="HorizontalContentAlignment" Value="Stretch" />
Style>
ListView.ItemContainerStyle>
<ListView.View>
<GridView>
<GridView.Columns>
<GridViewColumn Width="300" Header="Child">
<GridViewColumn.CellTemplate>
<DataTemplate>
<TextBlock Text="{Binding Path=ChildName}" TextWrapping="Wrap">TextBlock>
DataTemplate>
GridViewColumn.CellTemplate>
GridViewColumn>
GridView.Columns>
GridView>
ListView.View>
ListView>
StackPanel>
Border>
StackPanel>
DataTemplate>
ListBox.ItemTemplate>
<ListBox.ItemsPanel>
<ItemsPanelTemplate>
<StackPanel />
ItemsPanelTemplate>
ListBox.ItemsPanel>
ListBox>
StackPanel>Window>

<

DotnetNuke the great platform.

Thu, 07 Feb 2008 10:49:52 GMT

Started created my new site with DNN. I have used this product for years now and it keeps getting better. I have worked on many large scale enterprise implementation using the platform and I am hoping to blog about some of the issues you have when trying to scale the platform. As for my site its just going to be a place for me to blog so hopefully I wont need to concern myself with these matters! Below are some the sites I have developed previously.

www.hiscox.de

business.hiscox.co.uk

www.insurex.co.uk

www.glynoldboys.com

www.hiscox.fr

www.ontheblog.net