More Than Just Code?

I don’t like to acknowledge it, but I must say I am quite traditional. I get set in my ways and even easily hear in regards to a cool new way to do stuff it often takes me a while to bypass to trying it. An excellent example is NMock. I’ve known about NMock for probably after some duration, but I’ve stubbornly stuck with coding my own mock objects rather than offering it a spin. That is until today when I finally gave in and downloaded NMock2.

It’s amazing when you think that I am a champion of TDD in at least three organizations and I’ve given presentations and mentored people in TDD techniques, but I haven’t investigated such a core tool for doing TDD. But again I only began using Test Driven this year that I couldn’t possibly envision working without now. NMock is a mock object platform. You use Mock items and dependency injection in unit assessments to allow you to test an individual component rather than the whole stack. It’s probably one of most important core ideas behind TDD. NMock is a nice OO framework that leverages the powerful really .net representation API to make concrete instances of interfaces at runtime.

One thing got me for approximately around 30 minutes before I was saved by my colleague Preet is that you can’t mix bare quarrels with ‘Is’ parameters in the ‘Will’ clause. In the ‘Will’ clause you move the argument prices that you expect to be handed down to your mock method as I’ve done above.

But also you can use the very convenient ‘Is’ class that earnings a ‘Matcher’. Which means you can’t mix bare values with ‘Is’ arguments. The only other thing that disappointed me about an otherwise excellent tool, is that you can’t mock objects, only interfaces. The code I’m currently focusing on uses several abstract base classes and it would be really neat if NMock could provide mocks to them. I see that it is already a feature request, which it was available in NMock 1.0. Let’s wish they add it soon. More than just code? Jeff Atwood’s Coding Horror is one of the best blogs.

One of his recent content argued that most of us are so associated with the detail of our applications that we don’t step back again enough and ask why we’re writing about a specific piece of software. He suggests that we should become business attorneys and people and concentrate less on coding, or maybe even stop coding all together. Sure, what’s the idea in writing great code if it never ships or nobody ever is aware of it.

  1. How To Determine When It’s Time TO GET A New Grill
  2. Select “Sign Up for .Mac account later” then click on the Continue button
  3. Launch the net biz
  4. Send emails at the end of the day to avoid interrupting your connections’ daily timetable
  5. Host YOUR SITE, Pick a Theme, and Logo

Secondly is the complexity of modern society that needs deep specialization. There’s simply too much knowledge out there for anybody to be always a renaisance man in the 21st hundred years. I have enough trouble just keeping up with what’s happening in the world of .net development, let alone other dialects and platforms. There’s hardly any way that I’ve got enough mental bandwidth to be a great attorney or salesman too.

Inversion of control’ (also known as ‘dependency shot’ or the ‘dependency inversion principle’) is a common OO pattern that allows you to decouple the layers of your application by removing the dependency of customer class on a server class. It is not only good practice but essential for writing unit exams.

Rather than hard coding the server’s concrete type in the client, you make your client refer to a server interface or abstract class and inject the concrete server at runtime. Sometimes you’ll have the server injected by a co-ordinator or service course, however in many cases you desire to be in a position to configure the server to enable you to change the server’s type without having to recompile the application form. This becomes essential if you are writing a reusable framework where you want to allow your users to provide their own machines and indeed, the .NET foundation class collection uses this design extensively.

I also need a custom configuration section to put my providers in. Remember that we need to provide a ‘DefaultProvider’ property and a ‘Providers’ property. The DefaultProvider tells us which provider we ought to use, but we can keep multiple providers readily available if we, for example, want to permit the user to pick from them at runtime. The Providers property is of type ProviderSettingsCollection that’s provided for us in the System.Configuration namespace. Now, inside our client we get our custom config section and use the machine just.Web.Configuration.ProvidersHelper course to weight our providers, it’s so easy. After that you can just choose the default company or maybe give a list for the user to choose.

Here’s a sample company called XmlServerProvider. Note the Initialize method that you have to implement. It requires the name of the company and a name-value collection ‘config’ which have any properties that you might require to be arranged for your provider. In this case, from the normal name and description properties aside, the company also requires a ‘filePath’ property.