DotNetKicks.com - published patterns stories

Common design patterns

Thu, 12 Jan 2012 13:10:39 GMT

Common design patterns with .net

Inversion of Control Containers - Things You Should Know

Fri, 23 Dec 2011 08:43:03 GMT

Think you're a senior developer? Not yet senior, but interested in taking the next step? Today's topic in the "Things Every Senior .NET Developer Should Know" series will cover Dependency Injection, Inversion of Control containers, and my favorite Inversion of Control container, StructureMap.

Factory Overload

Wed, 21 Dec 2011 17:24:30 GMT

Recently I received a question from Kelly Sommers about good ways to refactor away from Factory Overload. Basically, she's working in a code base where there's an explosion of Abstract Factories which seems to be counter-productive. In this post I'll take a look at the example problem and propose a set of alternatives.

SOLID - Things Every Senior .NET Developer Should Know, Part 2

Wed, 07 Dec 2011 17:09:34 GMT

Think you're a senior .NET developer? Then you should already be familiar with SOLID, a set of five principles originally introduced by Robert Martin. These principles will help guide you towards better, more maintainable code and may help you have more fun at the same time. In this article, I'll cover the Single Responsibility, Open-Closed, Liskov Substitution, Interface Segregation, and Dependency Inversion principles.

Simple Producer Consumer with Tasks and .Net 4

Tue, 06 Dec 2011 20:30:57 GMT

Alois Kraus walks us through implementing a producer/consumer pattern using Tasks in .Net 4

Difference between dependency injection and mocking frameworks

Sat, 03 Dec 2011 03:30:31 GMT

The difference between dependency injection and mocking frameworks explained with examples

Implementing Chain of Responsibility Pattern

Mon, 14 Nov 2011 15:35:33 GMT

The Chain of Responsibility Pattern is implemented when a request or process is handled by multiple objects each fulfilling a single responsibility. This post describes how to implement a chain of responsibility pattern in .Net.

Introducing Autobox - on the fly DI container

Sun, 06 Nov 2011 07:21:11 GMT

This post introduces Autobox - on the fly dependency injection (DI) container.

The CQRS Dilemma and Related Random Thoughts

Thu, 03 Nov 2011 04:16:32 GMT

Anoop Madhusudanan writes about CQRS and why he is no longer a skeptic, and answers the question "Do I need CQRS?"

A look at Dependency Injection and Inversion

Thu, 20 Oct 2011 15:25:53 GMT

There seems to be a fair amount of confusion around this topic, a particularly useful tool in the SOLID toolbox, but in the wrong hands can go horribly wrong. Let's try and set the record straight now...

The Robot Factory Code Kata

Sun, 16 Oct 2011 02:33:38 GMT

On the drive home from my last Behavior Driven Development talk, I began thinking about the idea of Code Katas and how one might be appropriate in my future disucssions of Behavior Driven Development. Given that BDD tries to solve things in as simple and direct a path as possible, and given that BDD takes some of the lessons learned via TDD and applies them in slightly more business-centric language, a Kata would demonstrate well the effectiveness of BDD when applied to a problem domain. So, I took the example problem domain of a robotic assembly line that I've been using since I was a full-time trainer and implemented it using SpecFlow and Moq.

The three pillars of unit tests: A helpful guide for beginners

Tue, 11 Oct 2011 22:03:57 GMT

If you're new to TDD, then this short but sweet article by Pawel Olesiejuk is just what the doctor ordered. It covers the three pillars of test-driven development, which should push anyone just learning TDD in the right direction.

Avoid testing implementation details, test behaviors

Tue, 11 Oct 2011 23:25:23 GMT

Ian Cooper writes an excellent piece on avoiding test implementation details, concentrating on the Red, Green, Refactor cycle, and what actually requires testing. He goes on to explain how new classes are not triggers for new tests, but rather new requirements. Overall a well written article that distills some of the values Kent Beck's book: Test Driven Development. If you find yourself struggling with TDD, I'm sure this will clear things right up.

GRASP Patterns - Creator

Fri, 07 Oct 2011 23:20:07 GMT

This post presents one of the GRASP Patterns - Creator.

MSDN Magazine - 3 New Articles on Async/Await

Tue, 04 Oct 2011 18:51:56 GMT

This month's issue of MSDN Magazine is out with 3 new articles on async and await in the Visual Studio Async CTP. Stephen Toub shares these articles with us and gives us a suggested order in which to read them, sort of a one-stop shop for learning about the Async CTP.

GRAPS Patterns - Controller

Thu, 29 Sep 2011 23:50:08 GMT

This post presents one of the GRASP Patterns - Controller.

Domain Specific Software Engineering (DSSE)

Tue, 06 Sep 2011 04:15:01 GMT

Domain Specific Software Engineering

Data Access in Fail Tracker-Row-Level Security with LINQ to NHibernate

Tue, 06 Sep 2011 14:30:52 GMT

It's quite easy to implement row-level security using LINQ to NHibernate. See how you can do this by combining the Repository and Decorator patterns in this post.

Non-Virtual Interface Design Pattern

Sat, 03 Sep 2011 18:05:17 GMT

The non-virtual interface pattern is a design pattern that controls how methods in a base class are overridden. Base classes include public, non-virtual members that may be called by clients and a set of overridable methods containing core functionality.

The Ins and Outs of Thread Synchronization

Thu, 25 Aug 2011 03:42:06 GMT

Paulo Zemek takes us through the ins and outs of the different approaches to managed thread synchronization.

Fundamental MVVM

Tue, 23 Aug 2011 21:04:20 GMT

John Papa goes to great lengths to write an MVVM introduction for "the rest of us". He forgoes the heady, lengthy explanation and gives us a concrete sample that is easy to understand. For anyone who doesn't know the MVVM pattern, or is having difficulty understanding it or how it is useful, this post is for you.

Parallel Programming in C#

Sun, 21 Aug 2011 04:50:09 GMT

This is the first in a series of articles introducing the parallel programming techniques that are available in the C# programming language and the .NET framework version 4.0. The first part describes some of the concepts of parallel programming.

Design Patterns - The Builder Pattern

Sat, 13 Aug 2011 10:15:13 GMT

A quick Builder Pattern example in C# for .Net developers.

Encrypted Code: How to Get Your Code Completely Re-Written

Sat, 13 Aug 2011 02:45:17 GMT

What happens when you write unreadable spaghetti code? It gets re-written by the next guy.

MEF-(Managed-Extensibility-Framework)

Sat, 06 Aug 2011 01:44:28 GMT

MEF was around the corner for nearly some time now and it was available as one of the open source framework in Microsoft's open source community. (http://codeplex.com/mef). Now with lot of modifications and a finishing touch, it has been added as a new feature in Microsoft .Net 4.0. (Packed with Visual studio 2010) So what is MEF or Managed Extensibility Framework? What is it actual use? To answer, Managed Extensibility Framework (MEF) is a new library in .NET Framework 4 and Silverlight 4 that addresses the design problem of extensibility to some extend by allowing application to discover and use MEF extensions without using any configuration files. Here the application receiving extensions also should be MEF compatible and it will search for the MEF extensions on a particular path which is again declared inside the main application by any of the following ways.