The topics covered this time around are ‘Helping the Entity Framework play its <ROLE>’, looking at ways of using behavioural roles defined by interfaces in your system to be explicit and achieve high performance results, finer grained separation of concerns and greater configurability between your Domain Model and infrastructure. The second topic will be a practical look at getting started with NServiceBus, including demonstrations taking in messaging patterns such as Publish / Subscribe and full duplex.

While this is something that depending on the complexity and scalability needs of your site one may consider over kill, it is something that takes minimal effort in design to create a system that is innately more scalable. What happens when the data you are querying starts to push out is 5-10Mb of Data to a CSV file?

Option 1

So rather than generate the list of Foo into a CSV at each request why not pre generate the list at pre configured intervals depending on the volatility of the data and save the resultant CSV to a san that can be served up via IIS. In this scenario there is no need for the ASP.NET worker process to get involved and the IIS process can do what it was meant to do serve content.

Advantages

• No need to hit the DB to get the data
• You don’t have to involve the asp.net worker process and let IIS do what its designed to do

Disadvantages

• Your data may be stale up to a preconfigured amount of time (but since its going to a report of sorts it is more than likely stale)

Option 2

So your business requirement absolutely dictates that it is required to be generated and sent as the user requests it. There is no choice, you have but to send it through the response stream. BUT there is another way. Say when this request for the data to be exported VIA an AJAX call to your server the response from the server is a URL to where the file will be output. Now the server it self can then send a message to the export to csv service and request the file be output to the san. The client can then poll the server waiting for a 200 response code, when it does get one it can then redirect the browser to the given URL.

Advantages

• Gives you more or less up to the minute accurate data
• Reduces the amount of work the asp.net worker process has to perform

Disadvantages

• Introduces polling into the design of the client

When designing systems that do not take Scalability into account from the ground up, you generally are missing something. Considering Scalability does not mean that you choose either of these two options all the time. At times it might make sense to think about using the approach suggested in Scott’s article, the key being to always think about know your data and make informed decisions.

My reasons for attending the course again were simple

1. Gauge my progression
2. Hear other peoples thoughts and opinions
3. Spend more time at the feet of the master
4. And of course Learn some more

The beauty of this course is that despite the complexity of the architecture and the concepts the delivery makes the comprehension a breeze.  Paul Batum and Rhys Campbell who attended the course have written up their impressions, as has Simon and we all agree that it is worth its weight in gold. So if you have thought about ever doing this course and can make it to one do so, but if your not able to go to one of upcoming courses I would strongly suggest getting in touch with Udi and working other possible solutions with him. Which is why I guess Simon is owed big thanks for setting up this opportunity.

As for NServiceBus and its comparisons to Nuclear Armament, I can only say that once you have used it, there is a realization that there is great power that can be wielded without any effort. Till you can try it for yourself see what twitter has to say about NServiceBus. For me the next dose of sharing some NServiceBus love will be at Day 2 of Doing .net Days on the 27th February 2010 if you have nothing on that Saturday why not send an email to register a seat before they run out

That’s ok you say we are used to the Microsoft code name to product name shenanigans. Sure but its way more than just changing names and focus or both. This quite often has me having this conversation with myself

Me: What is Microsoft Distributed Caching product? Velocity?

Myself: No that’s the old name now its “Windows Server AppFabric”

Me: Ok thanks ill download that but what does AppFabric have to do with Caching? And where is the CTP of that application server that came from the “Olso” group? Dublin.

Myself: Oh you have that already?

Me: No all I have is that “Windows Server AppFabric”

Myself: Yes that’s Dublin.

Me: But I thought that “Windows Server AppFabric” is Velocity

Myself: Yes it is

Me: BUT BUT BUT….

Myself: No Buts It just is.

I hope that this constant cycle of change innovation duplication from Microsoft slows down to a pace that people can keep up with. Maybe even have a sniff of the roses and ensure that it is actually making a difference, and not just causing more noise from Redmond.

Command Query Responsibility Segregation – Udi Dahan from Mark Harris on Vimeo.

The first thing that went through our minds was that we had written the persister wrong, however a persistent Simon continued to work through the issues. Along the way we discovered a few things.

1. NHibernate is faster and therefore able to handle the load better.
2. Proper Saga Design is important.

NHibernate is faster

Most of you already know this but the key thing here is that because its faster it fails less therefore the issues that we saw in the development of the persister was difficult to isolate.

In the Manufacturing Sample that comes with NServiceBus start up all the required services and when the partner is ready run it in simulate mode, it does not fail. doing the same thing when using the L2S persister had the same effect.

Once the number of worker threads on the Order Service Host was increased to 4 could use we started to see a whole bunch of errors. From messages not being completed to violation of primary keys and deadlocks. Using the NHibernate persister required us to increase the workers to 6 or 7 you would start to notice similar errors.This leads me to the next item.

Proper Saga Design is Important

If your not sure about what a Saga is please read the NServiceBus wiki. When considering how you build a system  though that goes into how you would like to handle long running transactions is important. Knowing how many transactions per second. What are the SLA’s? My rule of thumb the more i think about it is that a Saga message that starts the saga should be unique any subsequent messages that are part of that saga should be dealt with a more explicit message handler. So you have a CreateOrderMessage that starts a saga and subsequent messages are handled by UpdateOrderMessages for changes to the order, with CancelOrderMessages and AuthorizeOrderMessages being explicit to the saga.

In my opinion doing so produces both a simpler and more explicit design of your long lived transaction. This however is now going down the path of a different post one that warrants a post of it own.

The Benefits of Reading code became clear the deeper we went through the NServiceBus code base, the more you understand how each piece interacts with the other to provide a great framework. Despite all the hurdles L2S provided it was worth the effort. What must be said for NServiceBus is that it is highly extensible already evidenced by its existing OOB support for 4 IOC frameworks, now 3 ORM’s and in the future with version 2.1 it will support a whole raft of Queued Transports.

This post has been sitting in my drafts for a while. After my day today i felt that it was best that i put my thoughts about service broker down.
In a project that i worked on about 2 years ago Service Broker was used as part of the system to perform data validation.  If success was measured by the amount of time that a system has been in production without major issues then i can say that it was successful.

But if a system was to be judged by how much of a pain it is to maintain then l must say that its was not a glowing success. Below is a list of things that i found as good or bad about it.

Bad things

1. Limited information on the internet
2. Testing is extremely hard (compromises everywhere)
3. Troubleshooting is a pain
4. It could stop working and you may never know, (if using a fire and forget mechanism)
5. Poison messages disable queues (would have been nicer if it moved the message to a error queue)

Good things

1. Its Asynchronous
2. Its Asynchronous
3. Its Asynchronous

Yes this list is one sided but true. The question that is important though is

Would i use Service Broker again?

The answer to that question is strangely YES. Only in very specific circumstances where system is ok with not having some data loss because of queue being disabled

What would I use instead?

NServiceBus of course. It provides an answer to all the negatives of service broker and is still asynchronous.

First off i know there should be no reason for me to do this as there are hosting options galore, but sometimes its just easier having the code running in your LAN, so with that in mind i remembered reading that Scott Hanselman wrote about his experience setting up VisualSvn on WHS. 

So i decided to follow his work and rather than reinvent the wheel, however as i went through the process i found that a couple of things needed changing to make this whole processes much easier.

1. Setup a new share on your home server using the Windows Home Server Console. The recommended approach is to Uncheck the Enable Folder Duplication Check Box, though i have yet to experience any of the locking issues described here
2. Log on to your Windows Home Server using Remote Desktop
3. Give the Network Service access to the share as well as permissions on the folder to Read/Write/Modify files as required. For a detailed walkthrough on what and how to modify the permissions are available in the VisualSvn Knowledge base article for Storing Repositories on a Network Share.

   NOTE: it is recommended that you create a special user that has Run As Service Account as well as the permissions to the folder and not use the Network Service.

4. Go to VisualSVN Download and begin installation
5. When prompted by the installation for a location for the share provide it with the share location that you have just setup.
6. Set choose port 8443 for your port and complete the installation. If the installer gives you any warnings its likely that you have not given the Network Service its required permissions.
7. Setup up port forwarding on your router. and you should then be able to access the Visualsvn from your Home Server url either http://server:8443/ if your inside your network or http://my-dynamic-dns.homeserver.com:8443/

The interesting thing about this is that while this is one of about 6 different ways i could count to do this installation while i found this the most straight forward for me YMMV.

Regardless of what the job is you want to find the most motivated individual. Sales people for example are motivated by great commission schemes. Interested Developers are generally motivated by good jobs and a great environment. Finding either a good job or a motivated developer is the hard bit. Simon Segal posted a while back about “Semi Invested Developers” and some ways to better understand the individual during the hiring process. If a developer was to have read his post in preparation for an interview and used some canned answers for those questions and managed to get hired he still shows more interest that one who has not bothered to take that step.

On a personal note I have reduced the number of hours I spent in front a computer since having my daughter (a time and energy vampire), however I have not lost my passion or motivation to better myself, and be a more interested developer. I find my self picking and choosing what tasks/technologies I will devote my attention to much more wisely, a skill that is very hard to acquire.

Just out of curiosity i created this poll to find out what people thought about hiring a half interested person /developer.

Let us being with looking at a sample handler.

   1: public class FileProcessMessageHandler:IMessageHandler<ProcessFileMessage>

   2: {

   3:     public IBus Bus { get; set; }

   4:     public IFileProcessor FileProcessor {get;set;}

   5:     public void Handle(ProcessFileMessage message)

   6:     {

   7:         if (FileProcessor.Run(message.FileIdentfier,message.FileSystemLocation))

   8:         {

   9:             var msg = Bus.CreateInstance<FileProcessedMessage>(m => {

  10:                                  m.FileIdentifier = message.FileIdentfier; });

  11:             Bus.Publish(msg);

  12:         }

  13:         else

  14:         {

  15:             Bus.Publish<UnknownFileTypeMessage>(m => { 

  16:                                 m.FileIdentifer = message.FileIdentfier; });

  17:         }

  18:     }

  19: }

This code in and of itself is highly testable. We have two interfaces that are injected into the class, excellent candidates for a mock. However when i first started down this path my first inclination was to use a manual mock, before moving on to trying to use Moq, however after spending time the fluent saga testing API in NServiceBus I realized that it was what was needed in this situation a MockBus.

MockBus is essentially the same as what is in the NServiceBus.Testing library. However because that version is geared towards testing sagas, it required changing the way the Saga class was created, and to allow for creating a version that would work with message handler. The new structure looks like the class diagram below.

What Changed

1. The Saga class has become the MockBus class and no longer has the static method called Test() which created the Saga instance.
2. The MockBusForSaga has the method CreateInstance<T> which replaces the Test() method in the old Saga class.
3. Introduced a MockBusForMessageHandler which has a CreateInstance<T,TK>() method that creates the message handler.

Having this structure now enables us to write our tests for our message handlers very simply in a fashion that does not require to understand Rhino Mocks, though having a understanding of the errors you get from the mock bus is important as all the messages that are bubbled out are Rhino Mock Messages.

   1: [Test]

   2: public void when_file_processor_succeds_message_handler_will_publish_a_file_processed_message()

   3: {

   4:     FileProcessMessageHandler msgHandler;

   5:     var mock_bus = MockBusForMessageHandler.CreateInstance

   6:                             <FileProcessMessageHandler,ProcessFileMessage>(out msgHandler);

   7:     var fileID = Guid.NewGuid();

   8:     msgHandler.FileProcessor = SetupAndReturnFileProcessor(true);

   9:     mock_bus.ExpectPublish<FileProcessedMessage>(d => d.FileIdentifier == fileID)

  10:         .When(() => msgHandler.Handle(CreateProcessFileRequest(fileID)));

  11: }

Lets have a look  when make a call to CreateInstance<FileProcessMessageHandler,ProcessFileMessage>(out msgHandler)

   1: public static MockBusForMessageHandler CreateInstance<T, TK>(out T handler)

   2: where TK : IMessage

   3: where T : IMessageHandler<TK>, new()

   4: {

   5:     handler = (T) Activator.CreateInstance(typeof (T));

   6:     var mocks = new MockRepository();

   7:     var bus = mocks.DynamicMock<IBus>();

   8:     try

   9:     {

  10:         typeof (T).GetProperty(“Bus”, BindingFlags.Instance | BindingFlags.Public)

  11:             .SetValue(handler, bus, null);

  12:     }

  13:     catch

  14:     {/**swallow if they dont have a Bus defined in the class**/}

  15:     List<Type> typesToMap;

  16:     MessageMapper mapper = GetMapperAndInitialize(out typesToMap);

  17:     return new MockBusForMessageHandler(mocks, bus, mapper, typesToMap);

  18: }

The beauty in this code is all hidden away in the MockBus (aka NServiceBus.Testing.Saga) thank you Udi for this,

The bus is instantiated when the object is created however no expectations are recorded until the When() method is called in the test just before the delegate is run. Once the delegate is run you will get the callbacks to the ExpectPublish where you can assert that not only did you get the correct type of message but the contents as well.

The code for this is available on the downloads page or go to it NServiceBus.Extensions.Testing download here