DotNetKicks.com - published patterns stories

Data structure zoo: 6 ways of implementing an ordered set

Thu, 04 Sep 2008 18:20:25 GMT

This article compares six different ways of implementing an ordered set: AVL tree, red-black tree, treap, splay tree, skip list, and a pre-balanced tree. The different data structures make different trade offs and ultimately arrive at curiously different solutions that fit a variety of real-world use cases.

High precision performance measurement

Thu, 04 Sep 2008 12:06:32 GMT

I've seen enough developers use DateTime.Now for their "quick and dirty " performance measurements. Enough is enough, it's high time to start measuring performance with precision and it's so easy that there's really no reason not to

Prototype Design Pattern

Wed, 03 Sep 2008 21:39:12 GMT

The prototype design pattern is a design pattern that is used to instantiate a class by copying, or cloning, the properties of an existing object. The new object is an exact copy of the prototype but permits modification without altering the original.

Working with SOA Design Patterns: Understanding Pattern Relationships

Wed, 03 Sep 2008 12:49:23 GMT

SOA design patterns can be -- and often should be -- interdependent. Implement a proper relationship between design patterns in order to make your SOA solution the best that it can be, suggests Thomas Erl.

Implementing the MVCA Pattern - The Model

Tue, 02 Sep 2008 13:43:30 GMT

The author of "MVC for the Real World" describes the Model and provides a simple implementation of a base model class.

MVC (Model View Controller) For The Real World

Tue, 02 Sep 2008 13:41:46 GMT

A look at the MVC design pattern and how to implement it in a truly presentation-agnostic fashion.

What's Wrong with a Data-Driven Approach?

Tue, 02 Sep 2008 04:51:13 GMT

Suppose we are building yet-another-order-basket-application. We have the requirement for adding items to an order, otherwise the business of our entire company falls down and we are losing tons of money (while not overdramatizing things).

Revisiting the onion

Tue, 02 Sep 2008 04:44:40 GMT

I'll start with my own version of the diagram because I spent enough &*%$ time on the thing. Wanna get some mileage out of it. Jeff's explained it pretty well, I think. It's clear that the Domain is at the centre and thus, is the focus of the application. I've skipped the Domain Service layer for two reasons:

The State Pattern

Mon, 01 Sep 2008 20:21:38 GMT

An introduction to the State Pattern: a behavioral design pattern that allows an object to partially change its type at runtime. The state pattern is a subset of the strategy pattern. The state pattern has a variety of uses, not least amongst them helping to encapsulate state changes of NHibernate persistent entities ssince it is usually undesirable to have a persistent entity change its type. The state pattern will also help you avoid brittle switch statements in domain logic.

Optimised IP address to country code mapping

Mon, 01 Sep 2008 20:04:08 GMT

Investigates the most efficient way to look up country codes from an IP address. Are Patricia tries really the best way to do it...?

Logging with Castle Windsor, the Logging Facility and log4net - Casey

Sat, 30 Aug 2008 23:42:00 GMT

Good info on hooking in Logging with Castle and Log4Net.

Great Design Pattern Resources

Mon, 01 Sep 2008 09:31:02 GMT

Some common patterns include the Singleton, Facade, Adaptor and Decorator. There are many, many patterns and below are some great resources to learn about them.

Domain Objects Pattern

Sun, 24 Aug 2008 04:37:20 GMT

Defines and describes the benefits of the use of Data Transfer Objects (DTOs).

Refactoring Ideas for ReSharper

Wed, 20 Aug 2008 09:59:07 GMT

I'd like to stick on the ReSharper theme for a while, considering that its features (or lack thereof, sometimes) are important for the kind of monotonous and potentially boring programming that I have done in both my MML# project and my new VhdlSharp project. Seeing how there are certain features I need persistently, I thought I would outline them here so that, when I get some time, I can implement them myself.

Persistence Ignorance and DDD with RepositoryBase

Tue, 19 Aug 2008 16:46:32 GMT

This post goes into developing a sample that uses the repository base implemented in my previous post, RepositoryBase. The post also shows how you can leverage RepositoryBase and achieve a degree of Persistence Ignorance by implementing two separate persistence layers using Linq to SQL and NHibernate and transparently swapping one out for the other without affecting your domain or tests.

Practical Concurrency Patterns: Immutability (Freezables)

Tue, 19 Aug 2008 09:29:35 GMT

Another very simple pattern builds on the foundation of the Safe-Unsafe Cache pattern. What is the easiest way to protect data from multi-threaded access and to incur the minimal performance cost while doing so? Making it read-only!

Writing Business Logic: Why follow Pattens / Practices?

Tue, 19 Aug 2008 08:24:00 GMT

In this post I will explain tips to expose functionality and abstract details of your business logic. However, instead of focusing on the technical details I will focus more on the need to use practices. I will take you through a real life example to explain why it is important to put significant thoughts into this concept.

CSS design patterns: Helper classes

Sun, 17 Aug 2008 07:44:57 GMT

Helper classes are reusable rules that use class selectors. Helper classes are designed to let you: 1) Apply style to an element without having to create a special rule for that element. 2) Abstract away browser inconsistencies. 3) Make documents more style readable.

Design Patterns - Proxy Pattern

Sat, 16 Aug 2008 19:12:17 GMT

Last part of a 16 parts Design Patterns series, talking about the Proxy Pattern.

Setting Sail with the Smuggling Pattern :: Part 1

Sat, 16 Aug 2008 01:04:38 GMT

Maybe because I'm often entertained by the geekiest of things, I've started usage of the Smuggling Pattern named after a fellow software architect Matt Davis's terminology of smuggling data into and out of Excel. It is something that I've lately needed to do on a regular basis, get data into and out of Excel without Excel, or at least the evil COM Interop Model, really knowing what is going on. In other words, I want total programmatic control over data so I can trust it versus Excel mangling my poor data up. This is what the Smuggling Pattern is going to do for me, and it is doing it well. Now you might think, "WTF!" But just to clarify, the Smuggling Pattern is really the Builder Pattern that we architects know and love with a cooler more fun more pirate like name! So with that, here's some of that code, and the TDD process I undertook to get this sucker built to set sail.

Austin DDD Book Club wrapped up - Jimmy Bogard

Fri, 15 Aug 2008 14:35:46 GMT

Talks about a book club on DDD that was started up in Austin and its benefits.

Strongly Typed Primitives

Fri, 15 Aug 2008 14:15:05 GMT

No, I'm not talking about NEANDERTHALS (there's a joke in there somewhere), but rather a technique that a colleague of mine, Josh Twist, has recently blogged about - "Avoiding Primitive Obsession to tip developers into the pit of success". I'd always seen a pit as symbolic of failure, so I'm pretty pleased there's such a thing as a pit of success - improves my odds massively J I've drawn attention to this because it is an approach I discovered a few years back, and I love it. I just use a slightly different implementation to Josh;

Surviving a Zombie Apocalypse - Behavior Driven Development Part I

Fri, 15 Aug 2008 13:16:18 GMT

Behavior driven development example using the walking dead.

Implementing a Repository and Specificaiton pattern using Linq

Fri, 15 Aug 2008 12:31:03 GMT

In my previous post I put down some thoughts on the Repository and Specification patterns and in the end said that with the introduction of Linq and the growing popularity of ORM frameworks and their support for Linq, it's time to look back at these two patterns and see how we can leverage Linq to simplify the patterns and make them infrastructure agnostic.

Onion Architecture in Praxis

Wed, 13 Aug 2008 21:23:26 GMT

Jeffrey Palermo has coined the pattern onion architecture, so what is it? Actually it is "just" my default architecture, and has been for some time now. The ideas behind are not new, and it is related to other principles and patterns. Never the less I really like having a name for it, so we have a common understanding of it.