DotNetKicks.com - published patterns stories

To Boldly Ask IT for Development Work

Mon, 29 Jun 2009 10:10:47 GMT

Are you ever mystified by the way that, in Science-Fiction films, the crew of space-ships are able to reprogram their ships' computers in order to respond to emergencies, needing no more than a brief klip...klop...klip on the keyboard to effect a huge software change. Phil Factor has found real-life in IT to be so different, and so he wonders if there a more realistic way that one might imagine IT's contribution to Space adventures.

Learning the Decorator Pattern

Tue, 23 Jun 2009 15:15:00 GMT

Taking at how we can use the Decorator Pattern in our application. The decorator pattern is a structural pattern which allows you to attach new or additional actions to an object dynamically. Using the decorator pattern provides a very clean and flexible alternative to subclassing (via inheritance) your object and thus creating an unwanted inheritance tree

Adventures in MVVM -- Ball of Mud vs MVVM

Sat, 20 Jun 2009 02:39:39 GMT

A demo that I added to my MVVM talk is one that compares a "Ball of Mud" application with a componentized MVVM application with the exact same set of features. I do this to contrast a messy, un-testable work of code to a cleanly separated, testable work. The application I chose to write is a Twitter search application in WPF. When you download the code, you will see two folders: "BallOfMud" and "MVVM".

My baby steps to PostSharp 1.0

Sun, 14 Jun 2009 03:15:20 GMT

So. you downloaded PostSharp 1.0 and you installed it and are wondering. "What's next?". Well my friends, let me walk you through the first steps of PostSharp. What could we do that would be simple enough? Hummm. what about writing to a debug window? That sounds simple enough! Let's start.

Design Patterns and Dependency Injection

Thu, 11 Jun 2009 18:41:52 GMT

Brian Prince and James Bender presented the following topics. (entry contains resources & contact information) Software Patterns by Brian Price & How I Learned To Love Dependency Injection by James Bender

Getting up and Running with Microsoft BizTalk ESB Toolkit 2.0

Wed, 10 Jun 2009 16:13:52 GMT

Microsoft BizTalk ESB Toolkit 2.0 released to web yesterday evening, and if you have not been following the earlier CTPs, now is a great time to get on board. The name has been changed, a support model has been introduced, and official MSDN forums for the Toolkit have been made available. Since there are not any VMs that you can simply download and get up and running with quickly, I decided to put together a quick and dirty installation guide for installing the Toolkit on a single server in a 32-bit virtualized environment for evaluation purposes. What follows are the steps to get you from 0 to ESB with all of the sample applications.

Observer Design Pattern with C#

Mon, 08 Jun 2009 21:37:35 GMT

The observer pattern is a design pattern that defines a link between objects so that when one object's state changes, all dependent objects are updated automatically. This pattern allows communication between objects in a loosely coupled manner.

Can you justify your actions with regards to this pattern?

Mon, 08 Jun 2009 03:46:42 GMT

Probably the most common problem with unintended complexity in software is the unthinking application of patterns. I see a lot more code that has became more complex through that practice than code that has became simpler. David Wheeler said: "All problems in computer science can be solved by another level of indirection;" However, we tend to forget the extra bit that Kevlin Henney's tacked at the end, "...except for the problem of too many layers of indirection."

Activity diagrams

Sat, 06 Jun 2009 07:31:55 GMT

Activity diagrams describe the workflow behavior of a system. Activity diagrams are similar to state diagrams because activities are the state of doing something. The diagrams describe the state of activities by showing the sequence of activities performed. Activity diagrams can show ac

The Waterfall Model

Sat, 06 Jun 2009 06:09:44 GMT

Waterfall model in software engineering

Gantt Charts

Sat, 06 Jun 2009 06:09:26 GMT

Gantt charts provide a standard format for displaying project schedule information by listing project activities and their corresponding start and finish dates in a calendar format

Should We Return Null From Our Methods?

Sat, 06 Jun 2009 18:15:06 GMT

I read a interesting article recently about the potential perils of Null Check Hell. The author's suggestion? Stop allowing any of your methods to return nulls, ever . No nulls returned, no null checks necessary. Problem solved, right?

The Stripper Pattern

Fri, 05 Jun 2009 16:41:20 GMT

In 2006 (if I can recall correctly), Greg Young and I discussed the concept of the Stripper Pattern, we never really had the chance to formulate it into a real pattern, but we kept discussing this whenever we met (and had beer available). This post is about the stripper pattern, and there is a good reason why I selected the accompanying image for this post, it is the spookiest stripper image that I can put in the blog. Because the Stripper Pattern is an anti pattern.

What is Continuous Integration - Wiki

Thu, 04 Jun 2009 17:16:34 GMT

Continuous Integration (CI) in software development is a set of practices and principles that speed up delivery of software projects and increase quality of their deliverables. Simply put, Continuous Integration takes a lot of mundane and boring things away from the process of software development, while letting developers to concentrate on more enjoyable and creative tasks...

StringDictionary class adds the key as lower-cased

Tue, 02 Jun 2009 06:58:17 GMT

Hi there, In a project I'm currently developing, we used the StringDictionary (In the System.Collections.Specialized namespace) class frequently for stored key value pairs. I noticed that all my keys were lower-cased. So when checking out the Add method with Reflector, I found out that the key is lower-cased. public virtual void Add(string key, string value) { if (key == null) { throw new ArgumentNullException("key"); } this.contents.Add(key.ToLower(CultureInfo.InvariantCulture), value); } As described on MSDN: The key is handled in a case-insensitive manner; it is translated to lowercase before it is used with the string dictionary. So if you want to use a string as a key and want that key string representation exactly to the same as you stored it, that use the following: // Use the Dictionary<string, string> instead of the StringDictionary, since StringDictionary stores it's key as case-insensitive Dictionary<string, string> items = new Dictionary<string, string>(); Nothing fancy, all standard .NET functionality, but this post is written as a reminder for myself and for you as a visitor of my blog. Hope this is usefull! gr, Robbert

Proxy design pattern demonstration

Mon, 01 Jun 2009 08:30:28 GMT

This code demonstrates the "Proxy" Design Pattern. The example shows delay of the expensive operation of loading a file from disk until the result of that operation is actually needed.

Cross-cutting concern - Wiki

Mon, 01 Jun 2009 05:05:24 GMT

In software development cross-cutting concerns are logical parts of the program that affect (crosscut) other concerns or modules. Examples of cross-cutting concerns are...

LINQ Expression Trees and the Specification Pattern

Mon, 01 Jun 2009 00:55:37 GMT

A very interesting article about DDD. David discusses implementing the Specification Pattern via LINQ's Expression type...

csharp abstract factory design pattern

Sun, 31 May 2009 00:42:24 GMT

The intent of the pattern, as described in Design Patterns, is to "Provide an interface for creating families of related or dependent objects without specifying their concrete classes.". Online example with source code.

Separate Domain from Presentation - part III

Sat, 30 May 2009 21:14:34 GMT

Last time we explained how to refactor towards MVP - Supervising Controller pattern. This post will: 1. Wire-up events communication between the view and the controller (presenter). 2. Separate concerns using interface between the view and the controller (presenter) 3. Suggest next steps.

The Greatest Exception Handling WTF?!? of All Time

Thu, 28 May 2009 10:00:00 GMT

The Exception object has ONE purpose and ONE purpose only - to represent a runtime error, nothing more. Exceptions should never be used for purposes for which they were not intended -- or you could end up with this monstrosity...

Creating Artificial Life with Cellular Automata in C# .NET

Tue, 26 May 2009 16:17:45 GMT

Cellular automata is a model of artificial intelligence involving the creation of single-celled programmatic life forms. Learn how easy it is to create artificial life right from your computer, using a little C# .NET and a few design patterns. In fact, Wolfram Alpha is based, in part, from this very science!

Learning the Observer Pattern w/ Callbacks

Fri, 22 May 2009 18:06:09 GMT

Taking another look at how we can use the Observer Pattern in our application, but this time we will implement the pattern using call backs and events. The Observer pattern allows you to define a one-to-many relationship inside your application where the parent object (the one) has the ability to notify the child objects (the many) of any state change. You can utilize this pattern to make sure that a set of objects are keep in order when there behavior needs to change based on the state of your application.

Separate Domain from Presentation - part II

Wed, 20 May 2009 04:10:36 GMT

This is a second post in the series of posts about "Separate Domain from Presentation" Refactoring. Previous Posts: Separate Domain from Presentation - part I. The post describes additional refactoring steps towards MVP - Supervising Controller pattern.

Unity InterfaceInterceptor doesn't support interface inheritance

Fri, 15 May 2009 06:37:19 GMT

The InterfaceInterceptor from Unity (Enterprise Library) is broken because it doesn't support interface inheritance. This post contains the solution.