Anuj Varma

The Publish Subscribe Pattern in C# and some gotchas

Anuj Varma — Wed, 17 Apr 2013 19:48:50 +0000

NOTE: With the introduction of two new interfaces in .NET 4.0, there is a cleaner way to implement the Publish Subscribe pattern in C# .NET. However, the ‘gotchas’ listed here still apply. Even with the new interfaces, one still needs to worry about things such as ‘unsubscribing from the publisher’, ‘badly behaved subscribers’, ‘new subscriber added while publishing is in progress’ etc.. The 4 main potential issues with any publish-subscribe implementation are summarized below. This post will discuss each issue in detail.

Gotcha 1 – One rotten apple – blocks the others. When multiple subscribers are present – what if one of the subscribers blocks the publisher so that it is effectively not available to other subscribers? This can easily occur if any one of the subscribers decide to do something lengthy (oh – like maybe run an infinite loop) in its event handler. How do we prevent such an occurrence? How do we prevent one rotten apple from spoiling the bunch?

Gotcha 2 – What if a subscriber is added while notification is in progress? Supposing the list of subscribers is being notified – and a new subscriber happens to come along (this is not a rare event – especially if any one of the subscribers happens to contain time-consuming code as in Gotcha 1) . What happens to the new subscriber? Does it get dropped? Do we add it? If so – where and when do we add it?

Gotcha 3 – Subscribers that fail to unsubscribe. A ‘good’ practice (maybe even a ‘best’ practice) in .NET eventing is to ensure that all subscribers eventually unsubscribe from their events – once they are done handling it. Failure to do so leads to potential memory leaks. This is actually one of the more common sources of memory leaks in .NET applications (see my blog on Common Sources of Memory Leaks in .NET Applications)

Gotcha 4 – Race conditions in the .NET eventing framework – leading to inconsistent handling of events.

ORIGINAL (OLD) WAY OF IMPLEMENTING PUBLISH SUBSCRIBE in .NET (View this post to see the new implementation)

The eventing mechanism built into the .NET runtime makes it a piece of cake to implement a simple publisher – subscriber pattern (C# code follows). The example below revolves around the ‘payday’ event – which is called PayrollArrived. The event is published by the Employer class (the Employer announces when payday arrives). Each Employee (i.e. each instance of the Employee class) listens for the event – and is hence a subscriber to the PayrollArrived event.

// Publisher Class – EmployerPublisher – will publish the PayrollArrived event
 
public class EmployerPublisher

{

   public event  PayrollArrivedHandler PayrollArrived;

   public void FireEvent(DateTime today)

   {

	if(PayrollArrived != null)

	  PayrollArrived(today); 

   } 

}  

// Subscriber class – Employee – interested in knowing when the PayrollArrived event occurs

public class Employee

{

	public void OnPayrollArrival(DateTime day)

       { 

		// Round up some friends and go spend the money!

       }	 

} 

// Hooking up the publisher and subscriber(s) in the client code

EmployerPublisher publisher = new EmployerPublisher();

Employee employee1 = new Employee();

Employee employee2 = new Employee();

publisher.PayrollArrived += employee1.OnPayrollArrival;

publisher.PayrollArrived += employee2.OnPayrollArrival;

// Now that the subscribers are hooked up, the event can be fired

DateTime now = DateTime.Now;

publisher.FireEvent(now.date);
 
However – there are a few gotchas to watch out for:
Gotcha 1 – One rotten apple – blocks the others. When multiple subscribers are present – what if one of the subscribers blocks the publisher so that it is effectively not available to other subscribers?  This can easily occur if any one of the subscribers decide to do something lengthy (oh – like maybe run an infinite loop) in its event handler. How do we prevent such an occurrence? How do we prevent one rotten apple from spoiling the bunch?
Gotcha 2 – What if a subscriber is added while notification is in progress? Supposing the list of subscribers is being notified – and a new subscriber happens to come along (this is not a rare event – especially if any one of the subscribers happens to contain time-consuming code as in Gotcha 1) . What happens to the new subscriber? Does it get dropped? Do we add it? If so – where and when do we add it?
Gotcha 3 – Subscribers that fail to unsubscribe. A ‘good’ practice (maybe even a ‘best’ practice) in .NET eventing is to ensure that all subscribers eventually unsubscribe from their events – once they are done handling it. Failure to do so leads to potential memory leaks.  This is actually one of the more common sources of memory leaks in .NET applications (see my blog on Common Sources of Memory Leaks in .NET Applications)
Gotcha 4 – Race conditions in the .NET eventing framework – leading to inconsistent handling of events.
Let us look at these one by one:
Gotcha 1 – One rotten apple….or the badly-behaved subscriber problem 
The badly-behaved subscriber problem is best solved by working under the assumption that all subscribers will be badly behaved! So what is a publisher to do? One solution is to launch each notification on a new thread – that way even if a subscriber is badly behaved – it does not tie down the notification of other subscribers. Since the CLR in .NET provides a ready-made thread-pool, this is a seemingly simple solution. In fact, all one needs to do is use the built in support for asynchronous delegates (the event defined in the publisher class is really just a delegate). How would this look?
 
public class EmployerPublisher

{

   public event  PayrollArrivedHandler PayrollArrived

   // This event firing is synchronous - i.e. the publisher instance is tied down until the subscriber finishes processing OnPayrollArrival

public void FireEvent(DateTime today)

   {

	if(PayrollArrived != null)

	  PayrollArrived(today); 

   } 

// This is an asynchronous version of the same event-firing - just fire it - and do not worry about how long the subscriber takes - since subscriber processing 

// is on a different thread.

   public void FireEventAsynchronous(DateTime today)

   {

	if(PayrollArrived != null)

	  PayrollArrived.BeginInvoke(today, null, null); 

   } 

}  
We are almost there. The only problem with the above code is a C# restriction – if you want to call BeginInvoke, your delegate (our event) can only have one target. We already have two targets (employee1.OnPayrollArrival and employee2.OnPayrollArrival) – so what do we do? How about if we take our delegate and look at all its  targets one by one – and call BeginInvoke on them one at a time? That should work around the original problem.
public class EmployerPublisher

{

   public event  PayrollArrivedHandler PayrollArrived

   // This event firing is synchronous - i.e. the publisher instance is tied down until the subscriber finishes processing OnPayrollArrival

public void FireEvent(DateTime today)

   {

	if(PayrollArrived != null)

	  PayrollArrived(today); 

   } 

// This is an asynchronous version of the same event-firing - just fire it - and do not worry about how long the subscriber takes - since subscriber processing is on a different thread.

   public void FireEventAsynchronous(DateTime today)

   {

	if(PayrollArrived != null)

      {

	 Delegate[] delegates = PayrollArrived.GetInvocationList();

         foreach(Delegate del in delegates) 

         {

		PayrollArrivedHandler handler = (PayrollArrivedHandler) del;

               handler.BeginInvoke(today, null, null) 

         } 

   } 

}    
Gotcha 1 (the badly-behaved subscriber problem) – is essentially addressed by letting the subscribers stay badly behaved. We just don’t care – we’ve still managed to notify all the subscribers successfully.
Gotcha 2 : A subscriber is added while notification is in progress 
This is a slightly trickier problem to solve. We still want to allow the new subscriber to add itself – but we do not want to interfere with the current notification process.
This solution is borrowed from Holub on Patterns - and works well in our scenario as well. The basic idea is that instead of having just ANY collection of subscribers – use a linked list to store subscribers.
Notification of the list of subscribers boils down to traversing the linked lists one node at a time. Say you are on some intermediate node – and a new subscriber arrives. Simply add the new subscriber (as a node) to the head of the list!
This way – it doesn’t interfere with the existing notification process – and is successfully added to the list of subscribers whenever the next notification comes around.
Gotcha 2  (subscribers added while notification is in progress) – is solved by ensuring that any new subscribers are added to the head of a linked list (containing all the subscribers)
Gotcha 3: Subscribers that fail to unsubscribe
The publisher holds a reference to every subscriber that has subscribed to its events. 2 subscribers – 2 references – 100 subscribers – hundred references. Unless each and every individual subscriber specifically unsubscribes after handling the event, the publisher does not release the reference to that subscriber. This leads to objects hanging around on the managed heap (and also potentially unmanaged resources (files, images etc.) that are held on to by the managed objects).
Gotcha 3 Solution – Ensure that subscribers always unsubscribe from subscribed events when they are done. 
NOTE: WPF uses something called the ‘Weak Event Pattern’ (basically a WeakReference from the publisher to its subscribers – which gets garbage collected if it has been idle for a period of time).
Gotcha 4 : Race Condition in the .NET eventing framework
This is not a publish-subscribe problem – but more an ‘eventing’ problem in the .NET framework. This ends up being a publish-subscribe problem nevertheless.
public class EmployerPublisher


{


   public event  PayrollArrivedHandler PayrollArrived;


   public void FireEvent(DateTime today)


   {


     // There is a possible race condition that can occur here


     // If another subscriber - on another thread - unsubscribes from this event,


     // the PayrollArrived suddenly becomes null


	if(PayrollArrived != null) // WILL THROW A NULLREFERENCE EXCEPTION


	  PayrollArrived(today); 


   } 


}  


Gotcha 4 Solution– A simple workaround is to ensure that the event is always initialized to an empty delegate – this way it will never be null.
public event  PayrollArrivedHandler PayrollArrived = delegate {};
Summary
.NET’s eventing framework makes it simple to create a simple Publish Subscribe solution – however – one has to be careful about certain trip hazards. None of these hazards are difficult to deal with – and with just a little due diligence, one can have a powerful messaging subsystem going within any application. Neglecting these little details can, however, cause serious problems including memory leaks, unfulfilled subscribers and even uncaught exceptions.
Full Source Code 

Download Solution – PublishSubscribe.zip

Using CSS Templates with ASP.NET MVC

Anuj Varma — Tue, 16 Apr 2013 14:48:04 +0000

Find a CSS layout that you like – one good source is freecsstemplates.org.
In your MVC solution, in the shared views folders, there should be a _layout.cshtml file. This file contains razor view engine syntax. What we need to do is incorporate the razor view tags inside the CSS template that we downloaded.
Here is a detailed youtube video showing how this might be done

All flash storage cluster…database performance may take a giant leap

Anuj Varma — Tue, 16 Apr 2013 07:32:30 +0000

http://www.techpageone.com/technology/enterprise-ssd-the-first-all-flash-storage-cluster/#.UWz9oZPviSq

Active Release Technique for Tennis Elbow

Anuj Varma — Tue, 19 Mar 2013 04:46:35 +0000

Rest your elbow – give it complete rest (goes the popular lore for treating tennis elbow). Well – I gave it complete rest. Not tennis, no golf, not even hours on my computer (only used touch screen devices).
In addition, spent months and months on conventional physiotherapy. I know every stretch/exercise ever invented for the elbow, arm and upper body.I could write a book. It would be useless though – cause all those exercises, while somewhat strengthening in nature, did nothing to lessen the pain – or cure the tendonitis. My case is not unique (a little googling will reveal cases of no-progress tennis elbow for months and months – and years on end).

Having pretty much tried everything (every ointment, every pill, every accu thing – pressure, puncture…), I was fairly disillusioned at the entire medical profession. Having seen no less than 6 orthopedics and 4 top-notch physical therapy clinics, I had lost all faith.

My brain kept saying – ‘It can’t be THAT hard – it’s just some overused tendons/muscles close to the elbow. How hard can it be to fix that’? So – I refused to give up – and kept exploring. That’s how I came across Active Release. Once again, going in with full skepticism – since every previously ‘highly recommended’ therapy had flopped miserably (miserably – because there after all the physical therapy and home exercises, there was less than a 20% improvement in the major symptoms).

I went to Dr. Zalinsky in Austin – a guy who specializes in Active Release Therapy – and sports injuries in particular.

His basic approach was very matter of fact ‘Yes- I’ve seen this a lot – and yes, let me first see if I can fix it.’

By now, I had become a complete skeptic when it came to anyone promising fixes. He did something next that completely changed my skepticism.

He pressed my eblow in a few tender spots, asked me to move (stretch) my arm in a few directions. First time, no result. He changes the point he is pushing – and asks me to stretch again.
No result again. This continues for about 5 minutes. Finally, he pushes a point on the opposite side of the elbow (one that wasn’t even hurting) – asks me to stretch – and I can instantly feel something correcting itself inside (even though it hurt like hell).

Now, he asks me to move my arm around. Almost no pain! Way better!. We repeated the process on the same point – and the pain was way better. It had magically subsided – although both of us knew that the relief may not be permanent – and that I would have to return.

Nevertheless, this was the first time (in months) – that someone had successfully used manual techniques (or any techniques) to produce an immediate reduction of pain.

‘Yes – we can help you’ he concluded after his 5 minute experiment. ‘It may take 2 sessions, it may take 4 to 6, but we can help you.’

In just two sessions, my pain was reduced by 50%, I was lifting things twice as heavy as before and not feeling the twinge. This is what my brain had being saying to me all along ‘It CANNOT be that hard. There has to be some way to fix this without waiting for 12 months!’

Active Release’s approach goes against the grain. ‘Resting’ the elbow will accomplish nothing – since there is something chronically pushing against a nerve (a muscle pulling/pushing on a nerve), that is not going to quit by itself. This pushing/pulling point has to be located – and then straightened out. Unless that is done, no amount of rest will straighten it out on its own.
I really do not claim to understand how it all works – all I know is that it works.

Letter to Sonia, Sheila and Rahul

Anuj Varma — Tue, 19 Mar 2013 03:33:41 +0000

The rapes have to stop. Right now. Not tomorrow, not next month, not within a ‘phased timeframe’. Right now.

All that is needed is effective policing – and enforcement of existing laws. Do not hide behind the ‘delay tactic’ of enacting new laws, forming committees or blaming it on the Indian male.

If you cannot stop the rapes, step down. You have no right to be in your power position. This is your TOP priority – not the economy, not the upcoming election – THIS! Basic safety of citizens. In no city in India can a woman go out alone after dark – and feel completely secure. Not because of Indian men – but because of Indian police (or lack there-of) – and because of Indian politicians such as yourself (who are unable to ensure that the police do their job).

The rapes MUST stop. Right now. Or you must be stopped – from holding your office.

The choice is yours.

Outlook messages open up in MS Word

Anuj Varma — Tue, 19 Mar 2013 00:59:28 +0000

Here’s what happens – you open outlook to compose a new message (or reply to an existing one). Instead of Outlook as your editor, MS Word takes over at this point. Confusion ensues – since Word’s window is always hidden behind outlook – and at times, becomes hard to find your message in composition.

After struggling with this issue, found a helpful article on how to turn off this behavior in Outlook.

In Outlook, simply go to Tool—>Options—>Mail Format – and uncheck ‘Use Microsoft Word to edit e-mail messages’

http://office.microsoft.com/en-us/outlook-help/turn-word-on-or-off-as-your-e-mail-editor-or-viewer-HP005242849.aspx

Windows Live Writer for Editing Pages

Anuj Varma — Fri, 15 Mar 2013 17:21:10 +0000

Editing blog ‘posts’ is straightforward in Windows Live Writer. To get to the ‘pages’ (created in WordPress) was somewhat hidden…

Editing ‘pages’ as opposed to ‘posts’ in LiveWriter

1. FILE—>Open Recent Post
You should see a side bar that contains ‘Drafts’, ‘Recently posted’ and your blog name (e.g. Anuj Varma)
Click on your blog name. You should see the right hand side display as shown below – This contains the ‘Posts and ‘Pages’ option.
Select Pages and you should be able to retrieve the pages on your blog as well as edit them.

Creating New Pages

File—>New Post—>Page

First Page–A free editor for Cold Fusion Markup (and HTML)

Anuj Varma — Thu, 14 Mar 2013 03:48:39 +0000

More recently, I returned to some Cold Fusion programming (In the late 90s, I owned and operated coldfusionprogrammer.com – a site dedicated to Cold Fusion development – but moved to other platforms since then).

I was pleased to see that the development server (CFServer) was still completely free of cost (downloadable here – choose ‘Developer Edition’).

The IDE (CF Builder), however, was not free. So – I started digging around – and much to my dismay, did not easily find a low cost alternative to writing CFML code. Then I came across ‘First Page’ – primarily an HTML editor – but one that understood CF tags as well. No bells and whistles like intellisense etc. – but at a very basic level, lets you write CFML and HTML code without any interruptions. In fact, the HTML editor is one of the most intuitive that I have seen.

So – with the free CF server – and the free IDE – I was up and CFing in no time. A few stumbling blocks were related to IIS 7 (and IIS 8) and adding datasources to ColdFusion Server. Once those are overcome, I was all set to do CFML development on my local box.

NOTE: If you are just looking for a free HTML and CSS editor (without CFML support), take a look at KompoZer .

Microsoft abandoning its brightest idea ( in a long time….)–The upcoming death of Silverlight

Anuj Varma — Sat, 09 Mar 2013 20:06:24 +0000

Microsoft seems to have come up with one of the greatest technologies of recent times. A technology that would change the way websites looked and performed. Far more powerful than HTML5 or Flash. With capabilities that HTML5 can only dream of coming close to (without years and years of additional toolkit development).

What does a technology leader do when they come up with the idea of the decade? One that would revolutionize the way people develop web applications?

Abandon it of course. Get disheartened by the adoption of a competitive product (HTML5) or an existing product (Adobe Flash). Consider their idea – ‘not worth it’ or ‘a long shot’. Except that it wasn’t. Not only was (is) Silverlight way more advanced (and richer in capabilities) than HTML5 and Flash, it is richer without requiring intensive lines of code. This post will try and explain (to Microsoft – who shouldn’t need explaining to), why Silverlight support is sorely needed.

Microsoft has been accused of lagging – rather than leading revolutions (especially when it comes to web technologies). Internet Explorer appeared way too late and (after 10 releases) is still not even in the top 3 browsers in terms of performance and usability (Chrome, Firefox and Safari win over it in all metrics – memory footprint, speed of page loads, search shortcuts etc.)

For once, they actually were set to be the leader in something. And something big. Something that would change the way websites looked and felt for the next decade. What is possible to build with a Silverlight website is the stuff of dreams.

HTML5 versus Silverlight

I would like to see HTML5 come close to the full runtime capabilities of the .net platform ( which is what the silverlight plugin provides ). Multithreading, asynchronous page loads ( and web service calls), http and non-http bindings to external services – all with a few lines of code and some configuration files. I’m not even going to touch on the streaming capabilities of silverlight or the auto resizing , auto scaling, auto aligning – features of Silverlight controls. Try building an HTML5 app with controls that correctly resize as you switch from single to dual monitors.
Yes -with proper toolkits, possibly HTML5 will do some of those things in the future. Silverlight already does. It’s like having all the requisite toolkits in one, very small footprint browser plugin.

Adobe Flash versus Silverlight

Flash is the current industry leader in rich content browser plugins. Their platform does take web development to a new level. Which is why the entire world jumped on to it. Flash changed the way websites looked after years of boring HTML pages.

Silverlight was all set to do the same thing. Take web look and feel to a whole new level. But more than look and feel, it would do something that Flash could not come even close to. By including all the runtime capabilities of (the already mature) .NET platform, Silverlight would offer unprecedented coding possibilities for web applications. Things that were hitherto difficult (if not impossible to do) – would all be available out of the box to Silverlight programmers. Asynchronous web page capabilities, multi threading – allowing for super responsive UI controls, WCF capabilities of talking to any type of external service – whether WS* compliant or not – whether HTTP based or not. All of this with the least amount of lines of code – and some configuration files.

To build an equally capable website in Flash would require far more code – and would still not have all the capabilities that are built into Silverlight.

Prototyping

Expression Blend and SketchFlow offered a super interactive (and awesome looking) prototyping experience. Not only could a developer throw together a web page’s interaction (button clicks, menu navigation etc.) quickly, a customer could interact with the exact same prototype and add his/her comments and feedback. All this in real-time. And all with super-model good looking web controls. Perhaps the greatest advantage to prototyping with these tools is that one can actually use most of the prototype screens to begin development. Unlike most prototyping tools, SketchFlow uses actual WPF and Silverlight controls. While Microsoft has still not officially abandoned these tools, they seem to be offering ‘works on this OS and this type of product only’ releases. Expression Blend can only be used to Windows 8 store apps. Once again, these are no ordinary tools – they would have marked a new era in prototyping tools – with super look and feel – as well as unsurpassed user-interaction capabilities. One can only hope that these tools are not completely abandoned by Microsoft.

Summary

I am too bummed out to write a conclusion on the death of Silverlight. Microsoft is clearly showing signs of brain fog (skewed, cloudy decision making). First, with the purchase of SKYPE (all they got for $8 billion was an additional installation screen asking if you would like to install skype on your windows box). If they continue to forge ahead with Silverlight (it is already a mature, fully developed platform), the simplest worst-case 2-year scenario would still have people craving for Silverlight websites – once they had an idea of what was possible.

Facebook– Essential Missing Functionality

Anuj Varma — Tue, 05 Mar 2013 01:28:40 +0000

For the world’s leading social networking site, these missing features are inexcusable:

Unable to edit status updates (there’s a trick that can be used on updates containing images – but not on regular, non-image updates).
‘Send’ button (e.g. while messaging someone) – is not keyboard accessible (there is no key you can press to ‘Send’ the message. No ‘Enter’, Shift Enter etc. Nothing.
That’s pretty primitive. It is only ‘mouse clickable’. A lot of users cannot use mice (RSI injuries etc.) – what are they to do?

I’d like to keep updating this list – let me know of your gripe ( s ) with FB functionality.