A lot of people have been quick to point out the fact that .Net 1.1 does not have generics, even though I forgot to mention that fact also. In response to this, here is how you can implement the ListEnumerable in a pre 2.0 environment:

 

    public class ListEnumerable : IEnumerable
    {
        private IList itemsToEnumerate;


        public ListEnumerable(IList itemsToEnumerate)
        {
            this.itemsToEnumerate = itemsToEnumerate;
        }

        public IEnumerator GetEnumerator()
        {
            return itemsToEnumerate.GetEnumerator();
        }
        
    }

I hope that clears that up!!

After I finished up recording part 3. I realized that I was not showing off as many ReSharper shortcuts as I could have. That will definitely change over the course of the next set of episodes. For the remainder of the series I will be recording the entire series “sans mouse”. Hopefully this will give people an idea of how productive you can actually be without using the keyboard mouse. As soon as I had finished recording the session I thought to myself “yikes, I made that list enumerable way more complicated that it should have been”. Instead of this:

 

    public class ListEnumerable<T> : IEnumerable<T>
    {
        private IList<T> itemsToEnumerate;


        public ListEnumerable(IList<T> itemsToEnumerate)
        {
            this.itemsToEnumerate = itemsToEnumerate;
        }

        public IEnumerator<T> GetEnumerator()
        {
            return new ListEnumerator<T>(itemsToEnumerate);
        }

        IEnumerator IEnumerable.GetEnumerator()
        {
            return new ListEnumerator<T>(itemsToEnumerate);
        }
    }

I could have simply done this:

    public class ListEnumerable<T> : IEnumerable<T>
    {
        private IList<T> itemsToEnumerate;


        public ListEnumerable(IList<T> itemsToEnumerate)
        {
            this.itemsToEnumerate = itemsToEnumerate;
        }

        public IEnumerator<T> GetEnumerator()
        {
            return itemsToEnumerate.GetEnumerator();
        }

        IEnumerator IEnumerable.GetEnumerator()
        {
            return itemsToEnumerate.GetEnumerator();
        }
    }

And of course, an even easier way (if you have .Net 2.0) is to just leverage the yield keyword inside of a method returning IEnumerable. Which is how I started off the discussion on iterators.

I have just concluded part 3 of a dnrTV series trying to demonstrate the usage of common design patterns in the context of building a simple employee contact book application.

So far I have been able to cover the following design patterns:

• Singleton
• Monostate
• Strategy
• Factory
• Gateway
• Iterator

I plan to conclude the series by talking about the following remaining design patterns:

• Command
• Proxy
• Decorator
• Specification

I thought now would be a good time to release the source so far so that people can follow along with the examples/refactorings going forward from this point on.

You can download the source code from here. You can also watch the first 2 episodes at these links:

• Part 1
• Part 2

The example is being kept simple enough so that people can hopefully grok the application of the design patterns. For any people who are already watching the series, your feedback is greatly appreciated.

In an earlier post, I had mentioned that a friend of mine (Terry Thibodeau) would be creating a series that detailed streamlining your OS installation process. I just finished watching part 1 of his series and the information is awesome.

If you are interested at all in saving time for yourself when you need to install an OS from scratch, you need to watch this series.

Check out Part 1 here.

Well, it's been a long time coming, I am finally posting the second video in my applied test driven development for web applications series.

Although this is video number 3, it is really a fresh start that tries to start with less plumbing than was originally present when I started the first video. This was done on purpose. The video has now been revamped to show people how to start working with the Passive View flavour of Model View Presenter. The lack of infrastructure will also allow me the opportunity to show people how TDD will be applied to all layers of the application. At the end of this video you will have a (semi) working Customer management screen. Over the course of the next couple of weeks (I will be consistent this time), we will proceed to drive out the remaining functionality of both the screen itself and the underlying layers required.

You will note that I am still making use of the old Northwind database. If anyone has any ideas for a small application that requires the use of a database, I am all ears. I would much rather build something that may be used (other than for learning), as opposed to the fictitious example that focuses around the Northwind database. Again, feel free to fire your ideas at me, and I can easily change the future video to actually build out the app in mind.

You will have to excuse the coughing and sputtering in this video, as I am recovering from a nasty bout of Sinusitis (first ever encounter).

Feel free to give me feedback on this video as you see fit!!

**** If you want to run the build on your local machine, make sure you make any necessary changes to the local.properties.xml file, and ensure that the folder specified by the database path in your local.properties.xml file exists******

I will also point out, that I am going to try to release a video at least every 2 weeks. It could be more frequent based on feedback and demand!!

Resources

• Source Code
• Flash Video
• Swiff Flash Player

Thanks to everyone who has provided awesome feedback to the current set of posts and screencast. My family and I are going on vacation tomorrow; so this will most likely be my last post for the next 2 weeks. I am making a request for people who are either following along with the screencast or interested in applying TDD to do the following:

• Submit requests for features you would like to see implemented in the sample application
• Submit aspx pages (no codebehind), that contain layouts for a screen(s) you want to see implemented using TDD
• High level client centric use cases

Here are my reasonings for this request. I have been practicing TDD for 3 years. I have been involved in the development of many applications of all shapes and sizes and technologies utilizing TDD methods. Unfortunately, I can’t bring most of you with me onto these projects (although you could bring me onto yours!!). Instead of me coming up with fictitious scenarios and features, I am counting on my readers to take the place of the client and help drive out the functionality of this “fictitious!!” application. With the submission of high-level use cases, combined (hopefully) with screen prototypes; this provides us with a scenario which is typical of well-run agile environments. A majority of the projects I have worked on have followed this approach, going so far as having the analysts creating screen mockups using plain old powerpoint!! Once the screen mockups and high level use cases are in hand, I can take the use case and break it down into measurable tasks that will become focal points for driving out small pieces of functionality using TDD.

I want this series of podcasts to become one of the places where people who are interested in seeing TDD practically applied to turn to. To do that successfully I need to depend on my readership to help drive the direction of the project. That way I will be providing information that will hopefully convey TDD in a meaningful,pragmatic way.

Thanks and get those requests in!!

I originally said that I was going to use a flash format and a torrent file as the media that would be made available to both watch/download the screencast material. I have never used a 3rd party swf viewer (aside from the flash player browser client). Eduardo Laranjeira kindly pointed me to the Swiff player from GlobFX. This is a free player that will allow you to play swf files that you have saved on your local machine, without the need for a browser based player.

This will give everyone the best of both worlds. The swf file will already be on the server available for people to watch on demand through the blog. There will also be an accompanying torrent file that people can use to download (and hopefully seed) the actual swf file to keep on their local machine.

Thanks to everyone who provided feedback and aided me in coming to this decision.

JP out!!

After a lot of thought, I have decided that from now on I am going to publish the videos on this site in two formats:

• A torrent file that will contain the full flash movie and accompanying source code. You could then use a standalone flash player like Swiff to watch the movie on your local machine.

The torrent for the Applied Test Driven Development – Part 1 (Video) can be found here. I have already received some kind offers from people who would like to seed the files also. If you are able to that would be greatly appreciated.

For those of you who are following along with my Applied TDD series there is one refactoring I forgot to do yesterday:

Notice the bolded code. It used to read mockView.Employees. Halfway through the session I decided to first tackle displaying a list of contacts and not employees.

 

I have just finished recording the second session for the ATDD series. The video is approximately 37minutes in length. In this session all that I focus on is getting a presenter and accompanying view working to display a list of Contacts in the AdventureWorks database. Topics that are introduced are:

• Constructor based dependency injection
• Interface based programming
• RhinoMocks for creating mock objects

The completed code and movie are in this torrent.

Any feedback/comments would be greatly appreciated.

Last time we left off adding in the compilation of the web project to our build process. If you remember back to when we introduced the database we brought in the concept of template files and replacement tokens that could be used to allow for multiple developers on a project with disparate machine configurations to build using the same build file without any changes required. What we want to do now is go the final step and take our standalone build file that is currently being used by individual developers (whether or not they are on a team), and use it to centralize the build process. We are going to set up an environment that a multi developer team can use to introduce a CI process into their environment. CI (for those of you that don’t know) stands for Continuous Integration. Let me stress something very important here. CI is a process, not a tool.  If you want to read a concise definition of CI, check out Martin Fowlers article on the subject. That being said, there are a lot of tools that can aid you in introducing CI into your developer environment. We have already been taking advantage of a couple of these tools:

• NAnt
• NUnit

The new tool that we are going to introduce today is CruiseControl.Net. CC.Net is basically an automated build server. You would typically set it up so that at regular intervals it would poll the source code repository and see if there are any changes, if there are it would:

• Update it’s local copy of the source code from the latest version in the repository.
• Perform a build against it’s local code base
• Run all unit tests, acceptance tests etc
• Generate status reports on the health of the build

Obviously, this is a very high level description of some of the things CC .Net can do. 

This blog post could turn out to be huge, so to save my wrists I am going to try something a little bit different. I am posting a screencast that demonstrates the entire process required to:

• Place a project under source control using Subversion
• Installing CC.Net
• Configuring CC.Net to build a project.

The video is available here. Enjoy. (warning – it is close to 1hr, commercial free!!)

A new episode that I recorded with Carl Franklin on DNRTv is now available for viewing. The show is a breakdown of implementing the Model View Presenter design pattern. I chose, based on feedback, to focus solely on the use of the pattern. This should help people who were feeling cluttered by the test-driven-development!! Of course, when I am developing applications, I always pragmatically apply test driven development. So to answer your question, yes I would have used TDD to drive out the functionality of the view and presenter as opposed to the ad-hoc coding that I did on the current show.

One of my goals for this blog, is to be an outlet to show the practical applicability of TDD, design patterns etc, in the building and architecting of enterprise applications. I also have screen recording software available on my machine, so if there are topics you would like me to VBLOG about, as opposed to hogging all the DNRTv slots, then please let me know and I will do my best to record a quick screencast on the topic.

I would finally like to thank all of the people who have taken the time to provide feedback both positive and negative. It is greatly appreciated.