General

StructureMap with Named Instance and With Method

Steve Michelotti — Thu, 15 Oct 2009 03:07:04 GMT

I ran into an interesting IoC issue today that was ultimately resolved by some extremely helpful email assistance by Chad Myers. I’ll post the solution here in the hopes that someone else will find it helpful. Here is the code to set up the example:

   1:  public interface IFoo

   2:  {

   3:      IBar Bar { get; set; }

   4:  }

5:

   6:  public class Foo : IFoo

   7:  {

   8:      public IBar Bar { get; set; }

9:

  10:      public Foo(IBar bar)

  11:      {

  12:          this.Bar = bar;

  13:      }

  14:  }

15:

  16:  public interface IBar

  17:  {

  18:      bool Flag { get; set; }

  19:  }

20:

  21:  public class Bar : IBar

  22:  {

  23:      public bool Flag { get; set; }

24:

  25:      public Bar(bool flag)

  26:      {

  27:          this.Flag = flag;

  28:      }

  29:  }

The key here is that Bar has a constructor that takes a Boolean parameter and there are some circumstances where I want Bar to have a true parameters and some instances where I want it to be false. Because of this variability, I can’t just initialize like this:

   1:  x.ForRequestedType<IBar>().TheDefault.Is.OfConcreteType<Bar>().WithCtorArg("flag").EqualTo(true);

That won’t work because that only supports the “true” parameter for IBar. In order to support both, I need to utilize named instances. Therefore, my complete StructureMapBootstrapper looks like this:

   1:  public static class StructureMapBootstrapper

   2:  {

   3:      public static void Initialize()

   4:      {

   5:          ObjectFactory.Initialize(x =>

   6:              {

   7:                  x.ForRequestedType<IFoo>().TheDefaultIsConcreteType<Foo>();

   8:                  x.ForRequestedType<IBar>().TheDefault.Is.OfConcreteType<Bar>().WithCtorArg("flag").EqualTo(true).WithName("TrueBar");

   9:                  x.ForRequestedType<IBar>().TheDefault.Is.OfConcreteType<Bar>().WithCtorArg("flag").EqualTo(false).WithName("FalseBar");

  10:              });

  11:      }

  12:  }

This now enables me to create instances of IBar by using the GetNamedInstance() method. However, the primary issue is that I need to create an instance of IFoo and Foo has a nested dependency on IBar (where the parameter can vary). It turns out the missing piece to the puzzle is to simply leverage the ObjectFactory’s With() method (in conjunction with the GetNamedInstance() method) which takes an object instance and returns an ExplicitArgsExpression to enable the fluent syntax. Therefore, these instances can easily be instantiated either way like this:

   1:  var fooWithTrueBar = ObjectFactory.With(ObjectFactory.GetNamedInstance<IBar>("TrueBar")).GetInstance<IFoo>();

   2:  var fooWithFalseBar = ObjectFactory.With(ObjectFactory.GetNamedInstance<IBar>("FalseBar")).GetInstance<IFoo>();

Just another example of how IoC containers can enable us to keep clean separation of concerns in our classes and enable us to avoid cluttering our code with the wiring up of dependencies.

What IoC Container do you use?

Steve Michelotti — Wed, 14 Oct 2009 19:22:13 GMT

I often get asked what IoC Container I prefer. Short answer: StructureMap. I love the fluent syntax for configuration. Overall, it’s easy to use, has many advanced features, and is very lightweight. I view the learning curve with StructureMap as relatively small. It is one of the longest-lived IoC containers (if not *the* longest) and has a huge adoption rate which means it’s quite mature and not difficult to find code examples online. For example, there is the StructureMap mailing list. Additionally, the community is very proactive – I just sent an email question to Chad Myers today and got a response within minutes that solved my issue. The creator of StructureMap, Jeremy Miller, has one of the most useful blogs around (in addition to his column in MSDN magazine).

Despite all this, there are still several other very high quality IoC containers available including: Unity, Ninject, Windsor, Spring.NET, and AutoFac. Unity is Microsoft’s offering in the IoC space and often it gets picked simply because it’s got the “magical” Microsoft label on it. In fact, some organizations (for better or worse – usually worse) have policies *against* using OSS software and your only choice is to look at the offerings on the Microsoft platform. Despite this, Unity is actually pretty good but by P&P’s own admission, there are instances where StuctureMap implementation is a little more elegant than Unity. But Unity does still have some compelling reasons to use it. In fact, if you are already using the Microsoft Enterprise Library Application Blocks, choosing Unity makes sense for a little more seamless experience.

Having said all this, there is one other major caveat to my preference towards StructureMap – it’s the IoC tool I’m most familiar with. Therefore you should take a recommendation from me (or *anyone*) with a grain of salt. Ultimately the features of the various IoC’s are going to be comparable and it’s the developer familiarity with that tool that is going to make the difference. For folks new to IoC, most of the uses are going to be for simple constructor dependency injection and all the IoC frameworks can handle that easily. Given the wealth of quality IoC frameworks, we need another IoC framework about as bad as we need another data access technology. :)

NoVa Code Camp – Code Samples

Steve Michelotti — Sat, 10 Oct 2009 19:30:45 GMT

Thanks to everyone who attended my session today at NoVa Code Camp. Both the code and PowerPoint slides are available for download.

Download samples for: MVC in the Real World. Check out the readme.txt file in Solution Items and all SQL scripts for creating the databases.

NoVa Code Camp

Steve Michelotti — Wed, 07 Oct 2009 19:44:31 GMT

This Saturday (October 10) I’ll be presenting at the NoVa Code Camp. Registration is still open.

I will be presenting “MVC in the Real World”. There are many great sessions on the schedule. Hope to see you there!

Richmond Code Camp - Code Samples

Steve Michelotti — Sun, 04 Oct 2009 20:11:26 GMT

Thanks to everyone who attended my sessions yesterday at Richmond Code Camp. Both the code and PowerPoint slides are available for download.

Download samples for: MVC in the Real World. Check out the readme.txt file in Solution Items and all SQL scripts for creating the databases.

Download samples for: C# 4.0 New Language Features.

I had several questions about some of the tools I was using during the presentations (all of which are free). For the zooming and highlighting, I was using a tool called ZoomIt. For the code snippets, I was just utilizing the built-in code snippets functionality of Visual Studio – however, I use a tool called Snippy to create all of my custom snippets. You can find links to those tools and many other tools I use on my Developer Tools and Utilities post.

MVP

Steve Michelotti — Thu, 01 Oct 2009 07:21:11 GMT

I just found out today that I was awarded the MVP designation from Microsoft in the area of ASP.NET. It has been a very busy 2009 for me, speaking at various user groups and code camps including CMAP, CapArea, RockNUG, SoMDNUG, FredNUG, and Richmond Code Camp. I would like to thank all of those user groups for having me present and I look forward to continuing my involvement with all of those user groups and more in the year to come.

With .NET 4.0 and the 2010 wave just around the corner, the upcoming year looks to bring some exciting enhancements in numerous areas including MVC, WCF REST, C# 4.0, Dublin, and the .NET framework in general.

Richmond Code Camp

Steve Michelotti — Mon, 28 Sep 2009 09:57:37 GMT

This Saturday (October 3) I’ll be presenting at Richmond Code Camp. Registration is still open.

I will be presenting “MVC in the Real World” – Move beyond MVC 101 and dive into aspects of building robust, real-world MVC applications. This demo-heavy presentation will show how to fully unit test the presentation layer with mocking and Dependency Injection. This session will show the benefits of using Inversion of Control (IoC) containers to create controllers with a custom controller factory. In addition to AJAX-enabling Views, we will explore how to build your own custom HTML helpers that can be reused across Views. By the end of the session we will cover Action filters, security, T4 templates, MvcContrib, FluentHtml, and more!

Hope to see you there.

Rails for .NET Developers - Review

Steve Michelotti — Sun, 23 Aug 2009 12:14:20 GMT

In an effort to continually improve as a developer, one of the things I do is read lots of books. Recently I read Rails for .NET Developers by Jeff Cohen and Brian Eng. Overall, I would definitely recommend this book to any ASP.NET developer that wants to learn more about Rails or wants to better understand the concepts behind MVC.

Given that ASP.NET MVC was heavily influenced by Ruby on Rails, I wanted to learn more about Rails so that I could have a better understanding of how MVC evolved the way it did and how it might potentially evolve in the future. The book did a very effective job explaining Rails concepts while drawing parallels to ASP.NET that I, as an ASP.NET developer, could easily grasp quickly. However, it was written when MVC was still in CTP form so almost all comparisons were from Rails to traditional ASP.NET (not MVC). Rails is completely different from traditional ASP.NET but *incredibly* similar to ASP.NET MVC. In fact, although I always knew that MVC was influenced by Rails, I never realized the extent of just how similar (I daresay identical in many areas) MVC and Rails are. I guess it’s true what they say: imitation is the sincerest form of flattery. :)

The book starts out giving a very high level overview of what a Rails application looks like – this provides a solid foundation for the rest of the book. The next two chapters give a good overview of key concepts in the Ruby language. The book does not pretend to be a full-featured Ruby language reference – it introduces the major language features needed to get up to speed with Rails quickly.

The second section of the book (chapter 4-9), make up the major content of the book. It describes Rails’ approach to convention over configuration, REST, CRUD, Routes, Views, and more. I really liked the explanation of the way REST works in the context of Rails. The sidebar at the end of chapter 5 also gives a quick explanation for how Rails handles the PUT and DELETE verbs which is something I think Microsoft should consider baking into the MVC framework. I found the examples dealing with grid data to be pretty good – it’s always struck me as interesting that when a traditional ASP.NET developers sees a <% foreach %> in an MVC app for the first time, they freak out. But this is commonplace in the Rails world and not a big deal at all. As long as your view models are clean, I’ve always felt that using a simple <% foreach %> loop with intellisense for your properites is still more desireable than <% Eval(“someProperty”) %> but I digress. The chapter on layouts and partial views was quite interesting and you can see the influence of the Rails partial in the MVC2 EditorFor concept. The layouts versus MasterPages discussion was interesting and, while there are many similarities, this was an area where I felt MasterPages shined.

The final section of the book dealt with TDD, integration with .NET, RubyGems, and future directions. These chapters were all of a very introductory nature but the TDD chapter did make me want to learn more about using RSpec with IronRuby (though the examples in the book were with Shoulda, not RSpec). Though there were only 5 pages at the end of the book that discussed ASP.NET MVC, it does make me wonder if they’ll eventually put out a second edition of the book that uses MVC comparisons throughout.

In general, there are several reasons why I think it’s a good idea to at least be familiar with Ruby on Rails. First, getting a better technical breadth is always helpful to making you a more well-rounded developer. Also, like me, you may be a developer that has no plans to move away from the Microsoft platform in the near future – but leveraging the best practices and concepts from other platforms can improve your own code as well (translation: we can learn a lot from Rails developers). Microsoft recognizes this and it’s the reason they built MVC and IronRuby. The last few years have seen a trend towards dynamic languages like Ruby and IronRuby will soon make the Ruby language a first class citizen in the .NET framework. Before you know it, you could find yourself using IronRuby with MVC.

My Visual Studio Shortcuts and Macros

Steve Michelotti — Fri, 08 May 2009 20:23:48 GMT

Often when I give presentations, I’m asked afterwards what Visual Studio add-ins I was using. The fact is that most of what you’re seeing are not expensive add-ins at all but either built-in Visual Studio functionality or custom Visual Studio macros that I have written and bound to keyboard shortcuts which give the appearance that they’re “built in” to Visual Studio. The following 4 minute video shows how I use these shortcuts to maintain a fast pace during my presentations and not bore the audience with a whole bunch of repetitive typing. The code for these visual studio macros can be found here. The complete list of developer tools that I use on a daily basis can be found here.

Verbal Graffiti

Steve Michelotti — Wed, 04 Feb 2009 04:39:30 GMT

These days it is absolutely essential to have solid communication and presentation skills as a developer. This will serve you well whether you are presenting at conferences and users groups or professionally on a day-to-day basis communicating with managers and colleagues. I’ve given many presentations at developer user groups and code camps and I’m always looking for little ways to improve my presentations. Recently I picked up a copy of The Exceptional Presenter by Timothy Koegel and it was a great book and a fast read. One of the sections in the book is entitled “Eliminate Verbal Graffiti” where Koegel discusses the importance of eliminating fillers such as “um”, “like”, “you know”, “I mean”, “so”, “uh”, etc. Among his recommendations for eliminating these are to pay attention to other people’s fillers, practice eliminating fillers during every day conversation, and to record yourself during a presentation and listen to the play back of yourself (yikes!).

Recently I recorded a developer screen cast on C# 3.0 so I figured I would use the opportunity to listen to myself in an attempt to identify (and eliminate) my own personal verbal graffiti. While I was dreading the thought of having to listen to my own voice recorded, I figured it wouldn’t be too bad because I’m generally *ok* with not using “um” all over the place. OH, the misery! The only good news in the ordeal was that yes, in fact, I did a decent job not using “um” a ton of times. Unfortunately, the rest didn’t go as smoothly. Within the first 2 minutes I heard myself use the word “so” multiple times. Once you’re really paying attention to yourself, it can become a little brutal.

The most helpful suggestion for deadening the pain came from my wife who suggested inventing the “so” drinking game. My wife: “Just take a drink every time you hear yourself say that word “so” – it will be fun!” Hmm, sounds to me like there wouldn’t be too fine a line between “fun” and inappropriately fast inebriation. So she moved to her next suggestion: “OK, next time you give a presentation at a user group, I’ll come and sit in the audience. You can wear the electric dog collar and every time I hear you say “so” I’ll give you an electric shock so that you can eliminate this from your lexicon.” Hmm, again. Some nagging feeling in the back of my mind is telling me my wife might take pleasure in “helping” me get over my issue just a little too much.

I think I’ll stick to the suggestions that Koegel puts forth in his book – I highly recommend this book to anyone looking to improve their presentation skills.