elkdanger.co.uk

New host at Poundhost

2010-03-10T00:00:00Z

I've just moved this site over to a VPS hosted by Poundhost.com, which was both surprisingly cheap and good value for money. Now I get to completely control my hosting environment on my own Windows Server 2008 R2 box with IIS7, instead of letting some other company do it with certain restrictions.

I only found out about them really from a tweet which was re-tweeted by Scott Guthrie this week, and would encourage anyone thinking about getting a VPS to have a look at these guys.

Cheers Poundhost!

New WCF article over at CodeProject.com

2009-03-03T00:00:00Z

Finally I found I had something to write about; an article on creating a remote file store using WCF, and it's hosted right now over at CodeProject.com. It basically shows you how to create a service-based remote file repository using the Windows Communication Foundation, which has been part of the .Net Framework since version 3.0.

Enjoy the article!

Simple object conversion pattern

2008-12-18T00:00:00Z

Here's a quick conversion pattern you can use if you've got a lot of object conversion going on within your project, especially where databases and web services are involved. Bear in mind that this is essentially what the adapter pattern handles, but doesn't involve any sort of inheritence. It's like a cruder version of that pattern. It's also not as quick to use as a simple linq projection. However, you might want to do that tranposition more than once, so you'd want to stick that logic into a utility method or something similar.

This approach just formalises that utility method and enables you to keep all these kinds of conversions in one place; under one roof, if you will.

My solution involves an interface and (optionally) a utility method. It's handy for when you've got a set of data objects that you want to easily transpose and modify in order to send through a web service call to a client. Even if Linq To Sql (for example) does support such serialisation with WCF services without having to do much work, this often isn't desirable as generally you, as the programmer, want more control over exactly which data is sent across the wire. You might want to do this to guarantee packet sizes, for example, not to mention keeping the interface intact since your domain objects will change.

Here's the interface for the converter. Objects which implement this interface support converting an object from one type to another:

public interface IConverter<TInput, TOutput>
{
	TOutput Convert(TInput input);
}

Very simple. As an example, an object which converts a series of integers to a series of strings might look like this:

public class IntConverterConverter : IConverter<int, string>
{
	public string Convert(int input)
	{
		return "Number: " + input.ToString();
	}
}

The optional utility method I mentioned earlier is simply a wrapper for converting a whole bunch of inputs in one go. It produces a list of outputs where each item in the list has been converted from each item in the input list. It's also been implemented as an extension method, so this will work with anything which implements the IEnumerable<T> interface:

public static IEnumerable ConvertAll<TConverter, TInput, TOutput>(this IEnumerable inputs)
	where TConverter : IConverter<TInput, TOutput>, new()
{

        IConverter<TInput, TOutput> converter = Activator.CreateInstance(typeof(TConverter)) as IConverter;
	List<TOutput> outputList = new List<TOutput>();

	foreach (TInput input in inputs)
	{
		outputList.Add(converter.Convert(input));
	}

	return outputList;
}

Here's an example of using this pattern to convert a bunch of domain objects to a set of data transfer objects (DTOs) with the intention of sending these objects to a WCF client. First, this is what the domain objects look like:

And here's the DTO I'm going to convert them to:

[DataContract]
public class PersonDto
{
	[DataMember]
	public string Name { get; set; }

	[DataMember]
	public string HomeTown { get; set; }

	[DataMember]
	public string [] EmailAddresses { get; set; }
}

The converter object to convert the domain object to the DTO is:

public class PersonDtoConverter : IConverter<Person, PersonDto>
{
	public PersonDto Convert(Person input)
	{
		return new PersonDto()
		{
			Name = input.Name,
			EmailAddresses = input.EmailAddresses.Select(e => e.Address).ToArray(),
			HomeTown = input.HomeTown.Name
		};
	}
}

And a quick example of converting a set of Person domain objects to a set of DTOs:

using (ExampleDataContext dc = new ExampleDataContext())
{
	var people = from p in dc.Persons

		     select p;

	var convertedPeople = ConversionHelper.ConvertAll(people);

	foreach(var person in convertedPeople)
		Console.WriteLine(person.Name);
}

So now instead of a hierarchy of objects representing a person and all the information we can associate with him, we've reduced it to a simple class with a fixed set of properties, allowing the domain object to change freely without affecting any public interfaces and services you might have. If the domain objects do change, you should only have to reflect that change in your conversion code in one place. You could go a step further and create an interface for each DTO which makes this even more flexible.

I've produced a small project containing all of the above code and the database schema for the DataContext used here, should you wish to borrow or play around with this at your own leisure.

Download the example project

New blog up and running

2008-10-15T23:00:00Z

I've finally got my new blog finished and uploaded, and here it is. Actually, once I had finished my personal blog, this one was just a case of altering the stylesheet and adding some bells and whistles, and I was good to go.

I've dumped Wordpress in favour of a custom implementation; I didn't need all the gubbins that Wordpress provided and since the advent of Linq and Linq To Sql I was able to find the time to complete such a project to my satisfaction. This time around, I'm using .Net 3.5, Linq To Sql and Sql Server and a whole lot of custom code.

These two sites make use of the UrlRewriter.Net library, which is a must-have bit of code. I also employ this neat trick of storing the Asp.Net viewstate on the server, which can reduce the page size considerably.

I also created a base library for all my L2SQL data context needs, and I'll be writing about that shortly. I used it as a base for all my middle-tier data entity 'managers' to provide some uniformity when querying data, and also to manage the persistance of the data context.

One thing left to implement is pingbacks, which should be useful should anyone feel the need to link to my site. It would make an interesting project though.

LinqToLfsWorld 1.0.2 released

2008-07-13T23:00:00Z

Just a quick post to say that LinqToLfsWorld 1.0.2 has been released - you can grab it from the project homepage.

This version of the library adds:

Support for serialization and deserialization to/from Xml and Json
A new demo website page, demonstrating the serialization features.
Some helper constants for use in your car type, track ident and steering method queries
A couple of bug fixes

The entity classes also support exposure through WCF services - I haven't added a test for this scenario yet to the project, but have verified in my own quick test project that it does work as expected.

I've written a more detailed account of how the serialization works on the 1.0.2 download page.

Querying LfsWorld with LinqToLfsWorld

2008-06-24T23:00:00Z

In this post I'm going to show you all the different types of queries you can perform with LinqToLfsWorld. For an overview of what the library is and how it works, please feel free to read an earlier blog post which takes you through the demo website (included with the library download file).

The Queries

With the library you can perform all the queries that you would normally be able to using a plain url to LfsWorld (according to v1.4 of the pubstat service, which is the latest version at the time of release). These queries are accessed through the LfsWorldContext. All the examples below assume I have already initialised my context with the name lfswContext, and called Dispose() when I've finished with it. Disposing the context is important so that it can free up memory and unregister internal event handlers. If you don't dispose the context, you might find some weird things happening if you've handled the context's RequestMade event.

Racer Stats

Required parameters: RacerName

var query = from stat in lfswContext.RacerStats
where stat.RacerName == "elkdanger"
select stat;

This query will either return no results or one result; LinqToLfsWorld supports the use of the Single and SingleOrDefault methods, so retrieving a single entity instance is quite easy.

Racer Fuel

Required parameters: RacerName

var query = from fuelInfo in lfswContext.RacerFuels
where fuelInfo.RacerName == "elkdanger"
select fuelInfo;

This query returns information about the fuel usage of a racer, on a given track in a given car.

Personal Bests

Required parameters: RacerName

var query = from pb in lfswContext.PersonalBests
where pb.RacerName == "elkdanger"
select pb;

World Records

Required Parameters: None

Optional parameters: Car, TrackIdent

var query = from wr in lfswContext.WorldRecords
where wr.Car == "XRG"
&& wr.TrackIdent == "000"
select wr;

The values for TrackIdent and Car are exactly the same as the pubstat service normally accepts, according to the pubstat documentation on lfsworld.net.

Hotlaps

Required parameters: RacerName

var query = from hl in lfswContext.Hotlaps
where hl.RacerName == "elkdanger"
select hl;

Hotlap Chart

Required parameters: TrackIdent, Car

Optional parameters: SteeringMethod

var query = from hlc in lfswContext.HotlapChart
where hlc.TrackIdent == "000"
&& hlc.Car == "XRG"
&& hlc.SteeringMethod == "ms"
select hlc;

The values for TrackIdent, Car and SteeringMethod are exactly the same as the pubstat service normally accepts, according to the pubstat documentation on lfsworld.net.

Hotlap Log

Required parameters: None

Optional parameters: Steering, LogFilter, StartTime, Lines

var query = from hll in lfswContext.HotlapLog
where hll.Steering == "ms"
&& hll.LogFilter == HotlapLogFilter.Top10
&& hll.StartTime == DateTime.Now.AddMonths(-1).ToUnixTimestamp();
&& hll.Lines == 90
select hll;

It's worth mentioning here the call to ToUnixTimestamp(). By importing the LinqToLfsWorld.Extensions namespace. As the name suggests, this method is an extension on the .Net DateTime object which translates it into a unix timestamp value.

Similarly, by calling DateTimeExtensions.FromUnixTimestamp(timestamp) you can convert a timestamp value into a DateTime object; again after importing the LinqToLfsWorld.Extensions namespace.

Hosts

Required parameters: None

var query = from host in lfswContext.Hosts select host;

Teams

Required parameters: None

var query = from team in lfswContext.Teams select team;

That is all the queries that can be performed with the LinqToLfsWorld library. Of course all of these queries can be made using the normal method syntax, such as in:

var query = lfswContext.RacerStats
.Where(stats => stats.RacerName == "elkdanger").Single();

And of course, such is the nature of Linq, all these queries are only ever executed on the server when the results are enumerated.

LinqToLfsWorld: A look at the demo website

2008-06-23T23:00:00Z

Now that LinqToLfsWorld has been out for a couple of days, I've got time to explain a bit more about the features, using the demo website as an example.

The v0.8 Preview release contains the code library and the demo website for you to have a look at the interface first-hand. I should probably mention that for release 1.0 this will probably change; I'll make the demo website a separate and optional download, and the library in a separate download on its own. This blog post will use that demo website as an example.

The Code

Here's the code from the code-behind file, which I'm going to be referring to throughout this post:

If you've ever used Linq To Sql, you would be familiar with the methodology at work here. Essentially, to query LfsWorld you would do the following:

Create a new instance of the LfsWorldContext
Write a LINQ query to retrieve results using one of LfsWorld's services (hosts, racer stats, world records, etc).
Step through the returned data or bind to a data control.
Dispose the instance of LfsWorldContext

Let me explain a few things about this, starting with the LfsWorldContext itself.

The context has a strongly-typed collection representing each of the services exposed in v1.4 of the pubstat service. To make these queries, it requires that you supply it your credentials which you use to access LfsWorld (either your username and password, or your ident key if you have one). You can do this in two ways - through the LfsWorldContext constructor, or through the configuration file (see Configuration below).

The context has CachingEnabled set to true by default - I've explicitly set it above just for clarity. Whenever you make a request to LfsWorld, the response gets cached for later. This is done for performance reasons and, given that LfsWorld access isn't free for premium users, protected your wallet! The cache time can be configured using the CacheTime property on the context - just set this to a Timespan value of your choice.

Another caching strategy at work here is to protect those users which do not have premium access to the LfsWorld service. Any request made within five seconds of another one will throw an exception, and no request is made to LfsWorld. This is also persistant across different context instances. This behaviour can of course be switched off if you do have premium access to the service, by setting the context's PremiumPubstatAccess property to true, which will allow you to make requests as quickly as you like. This property is false by default.

The next part at work here deals with an event handler, which allows you to detect when any request has been made through the context instance. This allows you to retrieve information about the url which was sent to LfsWorld, the response it got back, whether it was cached or not and the size of the data which was returned.

This piece of code actually builds the query. Note that it does just build the query and does not actually execute it. This is the nature of Linq queries - the data isn't retrieved until the results are evaluated (by using a for-each loop or converting to a list, for example). You should also note that the queries here can be quite fickle. This is a limitation of the current version of LinqToLfsWorld and will be improved by the 1.0 release.

What I mean by that is it is a bit limiting as to what you could use in that query. For example, if I was querying racer stats I would use a query like the following:

var stats = from s in context.RacerStats
where s.RacerName == "elkdanger"
select s;

This would work fine, as would:

string name = "elkdanger"
var stats = from s in context.RacerStats
where s.RacerName == name
select s;

But something like the following wouldn't (imaging GetRacerName() is some method I have created):

var stats = from s in context.RacerStats
where s.RacerName == GetRacerName()
select s;

What you would find is the context would try to sent a url to LfsWorld which queries for a racer's statistics, would would pass through an empty racer name parameter, resulting in LfsWorld returning you no data. In fact, you'll find that any method operation inside that query would produce a similar result.

Another thing you'll notice is that for the initial query, only the parameters that LfsWorld accepts for a given action will affect the query (for example, querying racer statistices only accepts a "racer" parameter) . This by design, and the intention is that users of LinqToLfsWorld will make their initial query using only the parameters available to them, evaluate that query and then use plain Linq To Objects to deal with any further filtering that they might need. This is the most flexible way and will give the programmer ultimate control over the resultset.

At this point in the example, we evaluate the query by converting it to a list, and selecting only those hosts which are currently populated. At this point in the example we have a plain old list of host objects in memory, which we can treat just like any other object.

Configuration

One thing you can't see in the code above is the configuration. LinqToLfsWorld allows you to use a custom configuration section to specify the same settings for all of your LfsWorldContext instances (you can override them of course), making it easier to use this library from multiple places in the same project.

The configuration file for the demo website project look like this:

These settings will apply to any instance of the LfsWorldContext that you create, but of course can be overridden by any instance also. The only required attribute here is authenticationMode, which should be set to 'IdentKey' or 'UsernamePassword'. Hopefully it should then follow that if you set authenticationMode to 'IdentKey', you must also supply the idenyKey attribute. Likewise for UsernamePassword authentication mode; you must supply the pubstatUsername and pubstatPassword attributes. For the next release an xml schema file will be available which will give you intellisense on this configuration section, so you don't have to remember these. For now you can refer to the example site.

The next post will more than likely be an update on how progress is being made towards the release of v1.0, once I have improved the expression parsing side of things. Enjoy LinqToLfsWorld so far!

LinqToLfsWorld 1.0 released!

2008-06-23T23:00:00Z

Just a quick post to say that LinqToLfsWorld 1.0 has been released; you can grab it from the project homepage on codeplex.com.

Whilst the interface hasn't changed, under the bonnet the expression parsing code has been vastly improved and you can now do a lot more with it, compared to the 0.8 release from the beginning of the month.

For example, with the preview code you couldn't write a query such as:

var stat = from stats in context.RacerStats
where stats.RacerName == GetRacerName()
select stats;

.. the point here being that the expression parser couldn't evaluate local expressions, i.e. any expression which didn't contain a parameter expression from inside the query itself (in the example above, this local expression would be the call to GetRacerName()). Now though, all expressions which can be evaluated before the query is even looked at are evaluated down to a constant value. This means you can call any method or access any property you like from inside the query.

Some of the common selection methods are now supported also; you can directly call Single, SingleOrDefault, First, FirstOrDefault, Last, LastOrDefault and Count on an LfsWorldContext query. You can also call Select, provided the query only selects either a single entity or a list of entities. In other words, you cannot create an anonymous type from these queries. This limitation is trivial however, since you can just convert your results into a list and use plain Linq To Objects to select only the fields you need. The example website included with the download demonstrates this.

This released also fixed a number of bugs which were flagged up from testing the preview version, mainly to do with caching and the expression engine.

There are a couple of issues I'd like to sort out with regards to serialization, which will come out as some sort of '1.0.1' release perhaps. Over the next week or so I'm also going to give you a full run down of each type of query you can perform with this library on this very site.

If anyone is using the library and finds any issues with it, please direct them to the issue tracker on the project home page.

LinqToLfsWorld v0.8 Preview

2008-06-01T23:00:00Z

After a bit of umming and arrrring I managed to make quite a bit of headway with a project I've been mulling over for a while - LinqToLfsWorld. It's a custom LINQ provider which allows the client to communicate with LfsWorld via its Pubstat web service.

What is that exactly? Live For Speed (LFS) is (primarly) an oAnline racing simulator, and LFSWorld is an online base for checking your racing stats, viewing and comparing hotlaps and watching other races in real time via a neat flash application. Pubstat is it's webservice which you can query to retrieve information about racers, hosts, teams and hotlaps. You send it a url and it will return either JSON, PHP or XML formatted responses.

Since it's url based, and it has a fairly simple interface, I thought it would be a good introduction into finding out what it takes to build a custom LINQ provider. My implementation isn't great nor totally versatile (yet), but it works and I'm pretty pleased with the project so far.

The reason the release is tagged as 0.8 Preview is because there's a couple of issues I'd like to sort out before I give it that 'release 1.0' milestone; the object documentation (currently there isn't any) and I'd like to work a bit more on the expression visitor, to make the queries just a bit more friendly.

So, if you're interested in having a look, please visit the project page on Codeplex and download the latest release and/or the source code and play around with it. Send me any issues if you want via the issue tracker, and feel free to contact me with any suggestions or queries relating to the project.

I'm going to publish a couple more articles over the course of the next couple of weeks as I improve the library, and to show you a couple more examples on how to use it.

Querystring Element Insertion

2008-04-01T23:00:00Z

One problem I frequently come across is having to redirect to a page using the current query string in the request, but also having to add new parameters. Furthermore, the parameters I want to add might already exist in the querystring, and if you're redirecting to the same page all hell breaks loose within a few clicks of the link.

The exact problem I'm trying to solve is this: I have one page which gathers parameters from the user for an advanced product search, which then passes the parameters through the querystring to a search results page. This page contains a GridView control that has column headings which also pass some values through the querystring (information about which column to sort on and in what direction - I'll blog about this another time). When the column is clicked, I still want to keep the information about the search and also the sort criteria. Not all of the parameters will be in the querystring at any given time.

I have to deal with this problem on a few pages, and I need a way to quickly and easily redirect to a url passing the current querystring parameters whilst at the same time injecting one or more new parameters if they don't currently exist. If they do exist, I might want to re-assign it a new value.

The (hopefully) obvious solution is to work with the querystring while it's still in the form of a Collection, rather than a string. Unfortunately for us, the Request.Querystring instance during a page is read-only. So how do we go about this?

What I've come up with is a pattern for achieving the solution, rather than a handy method or object. It's quick, painless and flexible, and here's the code:

Dim newQsColl As New NameValueCollection(HttpContext.Current.Request.QueryString)
newQsColl.Set(sortExpressionParam, sortExpression)
newQsColl.Set(sortDirectionParam, CType(sortDir, Integer))

Dim newQs As String = newQsColl.GlueElements("&amp;")

The last line I'll talke about in a second. This code snippet allows you to take the current querystring and essentially add more key/value pairs to it. Here I've used the 'Set' method to create the new key/value pairs; this method will add the new pair if the key doesn't exist, but will change the key if it doesn't exist. Exactly the behaviour I was after!

An extra facility I wanted to finish this off was some easy method to glue the elements together in a format I could stick straight back into a hyperlink without any fuss. You could create a special lightweight class to do this, but since I'm using Asp.Net 3.5 I used an extension method. Ideally I'd like to implement the following on any IDictionary (since that interface follows the same key/value element structure), but alas NameValueCollection doesn't inherit from such an interface.

Nevertheless here's my extension method, named 'GlueElements':

<Extension()> _
Public Function GlueElements(ByVal collection As NameValueCollection, _
	ByVal glue As String) As String

	Dim sb As New Text.StringBuilder()

	For Each key In collection.Keys
		sb.Append(String.Format("{0}={1}{2}", key, collection(key), glue))
	Next

	Dim result As String = sb.ToString()

	If Not String.IsNullOrEmpty(glue) Then
		result = Left(result, result.Length - glue.Length)
	End If

	Return result
End Function

This method simply loops through the keys in the collection and joins together the keys and values using a specified 'glue' string. It then outputs the result, stripping off the last instance of the glue before returning it. If you set the glue string to '&', you end up with a string suitable for inserting straight into a url as a querystring.

VB Dynamic Query Library woes

2008-03-30T23:00:00Z

According to my searches on the internet, not many people were having trouble trying to use the Linq Dynamic Query library inside a class library project.

The problem was that with my Asp.Net web project, I wanted to have my middle-tier code inside a class library which would then be referenced by the website (and another planned website later on). This class library would contain (amongst other things) my Linq data context and the Dynamic Query library. However, whenever I added the Dynamic Query library to the project the compiler would start complaining about missing objects.

After much tearing my hair out and research I still couldn't find the problem so I left it to work on something else. A similar issue arised when I was working on a completely unrelated piece of code, so it wasn't just attributed to the Linq library in my original problem. The real issue?

VB.Net class library namespaces. When you create a VB.Net class library project, you can specify a default namespace for everything in that library, and so when you are creating something inside a sub-namespace you leave off the default namespace which is already set on the project.

The dynamic library is implemented inside the namespace System.Linq.Dynamic, and so when I added it to my class library project the namespace it was in was actually MyNamespace.System.Linq.Dynamic. This meant that the System namespace now clashed with MyNamespace.System, and the data context which imports the System namespace, and was in MyNamespace, was importing the wrong one. Obviously, this was also happening to anything which imports the System or any sub-namespace of System. Which means essentially that the hellmouth opened and the world was in chaos. This issue doesn't arise in a normal web project, since you don't define a default namespace for classes. I haven't tried this, but I also assume the issue won't arise in a C# class library project since, while you can specify a default namespace for your classes, the compiler doesn't anonymously prepend your default namespace name onto the one you've explicitely set in the code file.

The solution is simple - dive into the code file for the Linq Dynamic Query library and remove the namespace declaration.

LCD HD44780 activities

2007-10-12T23:00:00Z

This blog opener isn't strictly about coding, but having some time off work recently I decided to do something that, for me, is pretty cool. What could possibly be cooler than displaying car data from my favourite racing simulator Live For Speed on an external LCD device!

View the finished project on YouTube

The image on the right shows the finished display, showing the car speed, gear and fuel tank level. It's updated in real-time using the game's Outgauge system - Outgauge uses network packets to communicate with the world outside the game, and cool applications have been built to control external hardware devices, from real car gauges to full-motion simulators. The whole device is pretty simple, and cost me just shy of £20 for parts. The LCD device is an HD44780-compatible supertwist LCD display (model #N27AZ from Maplin), and then all you really need is a parallel cable and a power source. I've powered my device from three 1.5v AA batteries, so for convenience I added an on/off switch. You can also add a potentiometer to the contrast input to the device, but I chose not to since I want it to display at full contrast all the time.

The parallel cable was also a bit of a DIY project in itself. I couldn't easily find (nor was willing to pay delivery for) a D25 male->male cable, but I did have a D25->C36 cable handy. So, I slaughtered one end of it, cut of the wires I didn't need and wired a 25-pin plug on the end!

At the moment the device is powered on batteries, but I plan to change this so that it's powered from a standard hard-disk connector. I've found that when configuring the LCD to display data on two lines the contrast dips considerably (which is why in the video below I'm displaying the data on only one line), and it's been pointed out that this could be the batteries not being able to supply enough current.

Connecting to the LCD

The rest of the work is done in software. I used the excellent LFSLib to retrieve the data packets from Live For Speed, and my own custom library to interface with the LCD. There are a couple of methods you can use in .Net to send data through the parallel port, and I used the inpout32.dll method. This Win32 library contains two main functions - one to send data and one to receive data. Once you've got the hang of using the parallel port, controlling the LCD unit is a fairly straight-forward affair. You basically send a byte of data representing an instruction, send a high voltage to the 'enable' pin (causing the LCD to read and act upon the instruction) then clear the enable pin again. There's an initialization sequence which you must follow, after which text data is sent by setting the RS pin to 'high' (letting it know you're going to send data) and then sending each character in turn down the data pins (setting the 'enable' pin high after every character). The LCD will advance the cursor after every character. You can optionally tell the unit where you want to start the text from, in case you wanted to centre the text on the display.

My device is not without it's issues (there's a rant coming up in a future post about the BackgroundWorker object) but it was a fun project to work on, and you should have seen the smile on my face once I got it working! If you know a little bit about electronics and can solder, definitely give some thought to attempting a similar thing. I've included some references below which helped me get this up and running. The next thing for me to do is to make an enclosure for it, and put the project to bed.

References

I/O Ports Uncensored: Part 1 Covers controlling the parallel port and connecting to a simple LED circuit.
I/O Ports Uncensored: Part 2 Covers the circuit and pin-out of the HD44780-compatible display unit.
Electronics Forum: Helped a great deal when I was learning how to do all this stuff, and troubleshoot problems that were arising.