• Turns a console application into a windows service which allows much easier debugging
• Uses a fluent interface to setup your services allowing easy in code setup
• An instance can be provided at install allowing multiple same services on the same machine (which means you won’t need to read this)

The project site has a good Getting Started guide, once your ready to install the service, simply run this in a cmd prompt in the same directory as your exe:

myservice.exe install /instance:test

(function($) {
    $.extend({
        getJSON: function(url, loadingSelector, data, callback) {
            if ($.isFunction(data)) {
                callback = data;
                data = null;
            }

            var loadingElement = $(loadingSelector);
            return $.ajax({
                url: url,
                type: 'GET',
                dataType: 'json',
                beforeSend: function() {
                    loadingElement.show();
                },
                complete: function() {
                    loadingElement.hide();
                },
                success: callback,
                data: data
            })
        }
    })
})(jQuery);

The arguments are the same as the standard function apart from the new loadingSelector argument where you specify the element(s) that should be shown on load and hidden when complete here is an example usage:

$.getJSON('/customer/list', '#loading', function(response) {
    $('#customers').html(response.content);
});

This will use the selector ‘#loading’ to select the element(s) you can use any jQuery selector, with some tweaks you could also extend $.post.

var someValue = 100;
var anotherValue = 555;
alert('someValue is ' + someValue + ' and anotherValue is ' + anotherValue);

This ends up being hard to read and also prone to errors when operators/quotes are missed or not matched properly, if this was C# we could do the following:

var someValue = 100;
var anotherValue = 555;
Console.WriteLine(String.Format("someValue is {0} and anotherValue is {1}", someValue, anotherValue));

This is much nicer it would be better if we had string interpolation but hey-ho maybe in a future version.

One of the great things about the dynamic nature of Javascript is that you can extend any of it’s types as they are all objects using the prototype keyword, so we can extend the String object and also make use of the arguments object to allow any number parameters to be passed in:

String.prototype.format = function()
{
   var content = this;
   for (var i=0; i < arguments.length; i++)
   {
        var replacement = '{' + i + '}';
        content = content.replace(replacement, arguments[i]);  
   }
   return content;
};

This allows us to replace the first code example with this:

var someValue = 100;
var anotherValue = 555;
alert('someValue is {0} and anotherValue is {1}'.format(someValue, anotherValue));

Which I think reads better than the static Format method as C# does not have built-in support for doing the following "test {0}".Format(123).

using (var connection = new SqlConnection(connectionString))
{
    connection.Open();
    var cmd = connection.CreateCommand();
    cmd.CommandType = CommandType.StoredProcedure;
    cmd.Text = "MyStoredProcedure";
    var firstParameter = new SqlParameter("FirstParameter", value);
    var secondParameter = new SqlParameter("SecondParameter", DBNull.Value);
    cmd.Parameters.Add(firstParameter);
    cmd.Parameters.Add(secondParameter);
    var reader = cmd.ExecuteReader();
}

There is quite a lot of ceremony in there to make a simple SP call, using a dynamic object we can reduce this down to:

using (var connection = new SqlConnection(connectionString))
{
    connection.Open();
    dynamic myStoredProcedure = new DynamicStoredProcedure("MyStoredProcedure");
    myStoredProcedure.FirstParameter = value;
    myStoredProcedure.SecondParameter = null;
    var reader = myStoredProcedure.ExecuteReader(connection);
}

As you can see it still requires the caller to look after the connection so that it can manage it properly and make sure that it is closed however now using the dynamic keyword we can make calls to properties that don’t exist but instead are resolved dynamically and treated as a SqlParameter using the name of the property as the name of the parameter and the value is used as the parameter value, also nulls are automatically converted to DBNull.Value as the value for the parameter.

The DynamicStoredProcedure object declaration looks like this:

public class DynamicStoredProcedure : DynamicObject
{
	protected string m_Name = string.Empty;
	protected IDictionary<string, SqlParameter> m_Parameters = new Dictionary<string, SqlParameter>();
	
	public DynamicStoredProcedure(string storedProcedureName)
	{
		m_Name = storedProcedureName;
	}

	public void AddParameter(SqlParameter parameter)
	{
		if (m_Parameters.ContainsKey(parameter.ParameterName))
		{
			m_Parameters[parameter.ParameterName] = parameter;
		}
		else
		{
			m_Parameters.Add(parameter.ParameterName, parameter);
		}
	}

	public override bool TrySetMember(SetMemberBinder binder, object value)
	{
		var convertedValue = (value == null) ? DBNull.Value : value;

		if (m_Parameters.ContainsKey(binder.Name))
		{
			m_Parameters[binder.Name].Value = convertedValue;
			return true;
		}

		var param = new SqlParameter(binder.Name, convertedValue);
		m_Parameters.Add(binder.Name, param);
		return true;
	}
	
	public SqlDataReader ExecuteReader(SqlConnection connection)
	{
		var cmd = CreateCommand(connection);
		var reader = cmd.ExecuteReader();
		return reader;
	}

	public T ExecuteScalar<T>(SqlConnection connection)
	{
		var cmd = CreateCommand(connection);
		var result = cmd.ExecuteScalar();
		var type = typeof(T);

		if (result.GetType().IsAssignableFrom(type))
			return (T)result;

		throw new InvalidOperationException(string.Format("Cannot convert result [{0}] to type [{1}]", result, type));
	}

	public void ExecuteNonQuery(SqlConnection connection)
	{
		var cmd = CreateCommand(connection);
		cmd.ExecuteNonQuery();
	}

	private SqlCommand CreateCommand(SqlConnection connection)
	{
		var cmd = connection.CreateCommand();
		cmd.CommandType = CommandType.StoredProcedure;
		cmd.CommandText = m_Name;
		cmd.Parameters.AddRange(m_Parameters.Values.ToArray());
		return cmd;
	}
}

I have added the standard Execute methods that you find on SqlCommand There are also times were you need to add a parameter explicitly for instance for output parameters and if you want more control over the configuration of the parameter in this case I have added an explicit AddParameter for these cases.

& "c:\foo\MyProgram.exe"

But once I tried to add any I kept getting errors, I tried various different quotes around the strings in different permutations however I finally got it working by specifying no quotes at all:

& "c:\foo\MyProgram.exe" -firstParameter $firstParam, -secondParam $secondParam

Just thought I would share this so that someone else doesn’t spend their time trying various different quotes.

I had a look round to find an existing one however all the ones I came across work in slightly different way compared to our existing webcontrol below is screenshot of how it looks:

The HtmlHelpers I found seem to work by taking the current page number and populating the page numbers either side so that the page number is always in the middle of the other numbers, our existing web control works by displaying a group of page numbers you can then use the ellipse button to move to the previous/next group of pages, for example:

given the above I can move between all the pages above and the selected will be displayed emboldened, if I want to move to the next group of pages I can either click the ellipse button or if I’m on page 5 I can use the > button both will display the next group starting from 6. After racking my brain I came up with an algorithm to support this with no viewstate being available.

Basically we can use the current page number to find the last page number in this current group, i.e. if were displaying groups of 3 and were on page 4 the last number in this group is 6 the first group is 1-3. We can then use this to find the start number for the group by taking this number and take off the group size – 1 (2 in this case). The only thing we need to provision for is that we haven’t gone over the page count which can be done by checking which is minimum between the last page number for the group or the page count. Once we have the boundaries of the group we can work out which buttons to display and which page to display fairly easily.

Here is the code to demonstrate:

  
public static MvcHtmlString Pager(this HtmlHelper helper, int currentPage, int pageSize, int totalItemCount, object routeValues) 
{  	
    // how many pages to display in each page group const  	
    int cGroupSize = 5;  	
    var pageCount = (int)Math.Ceiling(totalItemCount / (double)pageSize);   	
    
    // cleanup any out bounds page number passed  	
    currentPage = Math.Max(currentPage, 1);  	
    currentPage = Math.Min(currentPage, pageCount);  	
    
    var urlHelper = new UrlHelper(helper.ViewContext.RequestContext, helper.RouteCollection);  	
    var container = new TagBuilder("div");
    container.AddCssClass("pager");  	
    var actionName = helper.ViewContext.RouteData.GetRequiredString("Action");   	
    
    // calculate the last page group number starting from the current page  	
    // until we hit the next whole divisible number  	
    var lastGroupNumber = currentPage;  	
    while ((lastGroupNumber % cGroupSize != 0)) lastGroupNumber++;   	
    
    // correct if we went over the number of pages  	
    var groupEnd = Math.Min(lastGroupNumber, pageCount);   	
    
    // work out the first page group number, we use the lastGroupNumber instead of  	
    // groupEnd so that we don't include numbers from the previous group if we went  	
    // over the page count  	
    var groupStart = lastGroupNumber - (cGroupSize - 1);   	
    
    // if we are past the first page  	
    if (currentPage > 1)  	
    {  		
        var previous = new TagBuilder("a");  		
        previous.SetInnerText("<");  		
        previous.AddCssClass("previous");  		
        var routingValues = new RouteValueDictionary(routeValues);  		
        routingValues.Add("page", currentPage - 1);  		
        previous.MergeAttribute("href", urlHelper.Action(actionName, routingValues));  		
        container.InnerHtml += previous.ToString();  	
    }   	
    
    // if we have past the first page group  	
    if (currentPage > cGroupSize)  	
    {  		
        var previousDots = new TagBuilder("a");  		
        previousDots.SetInnerText("...");  		
        previousDots.AddCssClass("previous-dots");  		
        var routingValues = new RouteValueDictionary(routeValues);  		
        routingValues.Add("page", groupStart - cGroupSize);  		
        previousDots.MergeAttribute("href", urlHelper.Action(actionName, routingValues));  		
        container.InnerHtml += previousDots.ToString();  	
    }   	
    
    for (var i = groupStart; i <= groupEnd; i++)  	
    {  		
        var pageNumber = new TagBuilder("a");  		
        pageNumber.AddCssClass(((i == currentPage)) ? "selected-page" : "page"); 				
        pageNumber.SetInnerText((i).ToString());  		
        var routingValues = new RouteValueDictionary(routeValues);  		
        routingValues.Add("page", i);  		
        pageNumber.MergeAttribute("href", urlHelper.Action(actionName, routingValues));  		
        container.InnerHtml += pageNumber.ToString();  	
    }   	
    
    // if there are still pages past the end of this page group  	
    if (pageCount > groupEnd)  	
    {  		
        var nextDots = new TagBuilder("a");  		
        nextDots.SetInnerText("...");  		
        nextDots.AddCssClass("next-dots");  		
        var routingValues = new RouteValueDictionary(routeValues);  		
        routingValues.Add("page", groupEnd + 1); 
        nextDots.MergeAttribute("href", urlHelper.Action(actionName, routingValues));  		
        container.InnerHtml += nextDots.ToString();  	
    }   	
    
    // if we still have pages left to show  	
    if (currentPage < pageCount)  	
    {  		
        var next = new TagBuilder("a");  		
        next.SetInnerText(">");  		
        next.AddCssClass("next");  		
        var routingValues = new RouteValueDictionary(routeValues);  		
        routingValues.Add("page", currentPage + 1);  		
        next.MergeAttribute("href", urlHelper.Action(actionName, routingValues));  		
        container.InnerHtml += next.ToString();  	
    }   	
    
    return MvcHtmlString.Create(container.ToString());  
}

To use it from the screen you simply do:

@Html.Pager(Model.Page, 20, Model.TotalItems, new {Model.Description})

Hopefully this will help someone who needs a pager to work this way as opposed to the more common offset implementations.

Consider buying an electric before an acoustic the reasons being electrics are easier to play (thinner strings, lower action) they are also more adjustable you can also pick really good electric guitars for cheaper price a good example being the Yamaha Pacifica. Acoustics on the other hand are harder to play (thicker strings, higher action) and generally you have to spend quite a lot to get a good sounding and easier to play acoustic. When I first started I was borrowing a cheap acoustic off one of my friends and it was awful to play the action was ridiculously high (ok as a slide guitar!) half an hour and my finger tips looked like canyons!

Take your guitar to a luthier to get setup when I got round to buying quite an expensive acoustic at the time I thought it was ok to play so carried on learning on it, this was a mistake I took it to a local luthier on the island who did an amazing job of lowering the action right down while having no impact on the sound it was like having a brand new guitar and much easier to play (especially when learning barre chords).

Kit you need to buy should include:

• Electric tuner – Time should be spent getting your chord shapes, rhythm, changes etc… down and not spent ages trying to tune manually, until you can get good at the former.
• Capo – Seriously worth getting one especially before your barre chords are down or if changing key for singing is necessary.
• Picks – plenty of them brand doesn’t matter, make sure to get a range of different thicknesses

Don’t buy guitar learning books if they don’t include CD’s, DVD’s I made the mistake early on of buying a book on learning the guitar but didn’t include a CD or DVD so I couldn’t get any visual or sound feedback to see how I was doing rendering it pretty much useless, so I spent a bit more and got a book which included a CD so I could play along and also get feedback as to how parts should sound.

Learn chord boxes and guitar tab  as these 2 items are used everywhere from learning guitar books to YouTube guitar lessons so you should spend time to understand what they represent.

Buy Justin Sandercoe’s (www.justinguitar.com) Beginners Guitar Course if you can afford to do so if not you can view his lessons from his website but seriously consider making a donation as this is provided by Justin’s goodwill. I wish I had bought this from the beginning as this course has everything you need and following it will get you playing guitar if you put the time in.

Don’t worry about the rhythm until you have your guitar shapes sorted and are able to switch between them relatively quickly because until you can do this your rhythm sound stuttered.

When learning to use barre chords I was paranoid that my first finger was not long enough which was why I could not get the bottom E string barred this was of course not the case and was just getting the positioning right and building up strength between my thumb and first finger, this just takes time, it may also be that the guitar action is too high.

Take some time out to learn a riff or a certain song you have wanted to play by checking YouTube for guitar lessons on it you can quickly establish if it’s within you current ability and makes you feel good once you can play it, for instance after a few month’s in I was on Beatles Rockband and was playing Day Tripper I liked the riff tracked down a guitar lesson and was able to play it after about an hour (slower than the record of course!) I also like Oasis and found that a lot of there songs are great to play as most are open chords. Doing this kind of stuff keeps it fun which keeps you interested.

Singing and playing is difficult I’m still trying to get to grips with this, as I always find that my rhythm goes to hell once I get passed the first line! I would recommend going slower than the record and picking a song you know inside out.

And the most important…be prepared to put lots of time in you really need to put the hours in to progress and you want to aim to do a few hours over a few days rather than play for many hours on a single day.

Hopefully this will in some way help others who want to learn to play guitar, I’m really glad I took up playing the guitar it lets me unwind from programming and makes me happy, good luck and enjoy playing.

Anyhow I googled around and found the MS Sync Framework which is specially created to deal with these scenario’s and out of the box comes with providers for dealing with file synchronization great stuff! The framework is pretty big as it has extension points to let you do stuff with custom providers (for other transport synchronization), custom data transformation, metadata stored items etc… however for what I wanted I barely needed to scratch the surface.

In it’s most basic form you end up with the following code:

FileSyncProvider sourceProvider = null ;
FileSyncProvider destinationProvider = null ;

try
{
    sourceProvider = new FileSyncProvider(
        sourceReplicaId, sourceReplicaRootPath, filter, options);
    destinationProvider = new FileSyncProvider(
        destinationReplicaId, destinationReplicaRootPath, filter, options);

    destinationProvider.AppliedChange +=
        new EventHandler <AppliedChangeEventArgs>(OnAppliedChange);
    destinationProvider.SkippedChange +=
        new EventHandler <SkippedChangeEventArgs>(OnSkippedChange);

    SyncOrchestrator orchestrator = new SyncOrchestrator ();
    orchestrator.LocalProvider = sourceProvider;
    orchestrator.RemoteProvider = destinationProvider;
    orchestrator.Direction = SyncDirection.Upload; // Sync source to destination

    Console .WriteLine( "Synchronizing changes to replica: " +
        destinationProvider.RootDirectoryPath);
    orchestrator.Synchronize();
}
finally
{
    // Release resources
    if (sourceProvider != null ) sourceProvider.Dispose();
    if (destinationProvider != null ) destinationProvider.Dispose();
}

There is one gotcha that caught me out, the MS Sync Framework will not do any of the scheduling of when the synchronization is performed that is completely dealt with by you, so in my case I was back to using a FileSystemWatcher to watch for file changes in the source folder and once a change was detected I would then tell the SyncOrchestrator to synchronize this seemed to work fine and was not that much extra work. The only other step was to wrap this functionality up to be used from a windows service and that was it! Overall I would recommend anyone looking to perform synchronization to take a look to see if either there’s something out of the box the framework gives you or if it can give you a head start.

 
var row = new TableRow(); 
var cell = new TableCell()
    { 
         Height = Unit.Pixel(30) 
    }); 
cell.Controls.Add( new Button() 
    { 
        Text = "Go",
        CommandName = "Go",
        ID = "btnGo" 
    }); 
row.Controls.Add(cell); 

How about this instead:

 
var row = new TableRow(); 
var cell = row.AppendControl<TableCell>(x => 
                  { 
                      x.Height = Unit.Pixel(30); 
                   });
cell.AppendControl<Button>(x => 
    { 
        x.Text = "Go";
        x.CommandName = "Go";
        x.ID = "btnGo"; 
    });
 

Implemented with this:

 
public static ControlExtensions 
{ 
    public static TControl AppendControl<TControl>(this TControl control, Action<tcontrol> initialization) 
        where TControl : Control, new() 
    { 
        var controlToAppend = Activator.CreateInstance<TControl>();
        intialization(controlToAppend);
        control.Controls.Add(controlToAppend); 
        return controlToAppend; 
    } 
} 

I think this reads better especially if you end up appending lots of child controls, thoughts or any other solutions?

Say we have a Car object:

public class Car
{
    protected Engine engine;
    protected Door[] doors;
    protected Wheel[] wheels;

    public Car(Engine engine, Door[] doors, Wheel[] wheels)
    {
        Check.PreCondition(engine != null, "engine must not be null");
        Check.PreCondition(doors != null, "doors must not be null");
        Check.PreCondition(wheels != null, "wheels must not be null");

        this.engine = engine;
        this.doors = doors;
        this.wheels = wheels;
    }

    public void EnableCentralLocking()
    {
        doors.ForEach(door => door.Lock());
    }

    public void Start()
    {
        engine.TurnOver();
    }
}

The code above is used to demonstrate a context wereby we have an object that takes a number of other collabarators which are then delegated to when certain behaviour is required this is a common event in OO, You can see I use a custom assertion class to make sure the collabarators are not null.

One thing we pick up on is that different behaviours that the Car object is instructed to perform may effect only one collabarator or may effect them all for instance EnableCentralLocking effects the doors collabarating object but has no effect on the wheels or engine.

Unit testing the above

Ok so now we want to unit test the Car object:

[TestFixture]
public class when_central_locking_enabled
{
    [Test]
    public void should_tell_all_doors_to_lock()
    {
        var engine = new Engine();
        var wheels = new Wheel[4];
        var doors = createStubDoors();

        var sut = new Car(engine, doors, wheels);
        sut.EnableCentralLocking();
        doors.All(door => door.Locked);
    }
}

Here I use a state based way of testing the doors have all been locked. One thing is apparent in order to create the Car due to the assertion checks at the beginning I have to create all the collabarators now if I was testing a behaviour that required all of them this is a must however to test the central locking the doors is the only collabarator I need, the creation of the others is just a wasted overhead.

Now this is how I currently create my objects that require collabarators and I was ok with this however recently I was told by a friend to check out a blog by Misko Hevery I was astonished by how well written and the information surrounding good OO and unit testing was, anyhow I came across this post which made me think about whether we should be asserting the collabarators in the constructor or not.

If we remove the assertions our test becomes:

[TestFixture]
public class when_central_locking_enabled
{
    [Test]
    public void should_tell_all_doors_to_lock()
    {
        var doors = createStubDoors();
        var sut = new Car(null, doors, null);
        sut.EnableCentralLocking();
        doors.All(door => door.Locked);
    }
}

We removed the overhead of creating the collabarators not needed for the test however our code is open to NullReferenceExceptions being thrown if were passed a null collabarator, hmmm… a real head scratcher! 

What are the options?

1. Make the responsibility of making sure objects are created be assigned to a factory object or on an IoC container
2. Initialize the fields with NullObject values, and use a property to access the field so checks can be made (this would not be enforcable)
3. Keep the assertions but allow your assertion library to be context aware, at runtime in your unit tests allow it to be in a fall through mode
4. Keep the assertions and accept the overhead, use Test Data Builder pattern / Object Mother to cut down on repeated code
5. Move the assertions into the methods, this could cause a lot of DRY violation and extra overhead.

As with most of these things it’s a balance between acheiving 100% defence and overhead required in our unit tests, after looking at the options I could come up with I’m inclined to favour 1 or 3.

What would you use? Do you have any different options about how to balance the 2 out?