DotNetKicks.com - Stories tagged with Patterns

Get injected into the world of inverted dependencies

Fri, 18 May 2012 13:34:19 GMT

My attempt to introduce you to the world of dependency injection and inversion of control containers. I'll show you what the fuzz is all about and how you can write more robust code thanks to a container.

The SOLID principles with real world examples

Fri, 11 May 2012 21:23:11 GMT

The following article aims to explain the five SOLID principles with real world examples. The SOLID principles are five programming principles which is considered to be the foundation of every well designed application

Some Servicelocator pattern stinks

Wed, 18 Apr 2012 13:55:46 GMT

I have been working on a somewhat legacy codebase which makes use of the Servicelocator pattern. Although I always thought of Dependecy Injection to be the superior pattern, I was pleased to find some Inversion of Control implementation in there. Working with the codebase, I discovered first hand how easily, when used without caution and discipline, the Servicelocator pattern can introduce code rot.

A good way to keep your entities clean

Sun, 18 Mar 2012 23:04:04 GMT

This tutorial will show you how to keep your entities and your views clean by translating entities to viewmodels. It is a good practice to do this because it keeps your files clean, it avoids certain security problems and it's more flexible, as you will read in this article. The examples are using C# and ASP.NET MVC, but the concept is pretty generic and can be applied to virtually every programming language or framework.

The Law of Demeter

Sun, 19 Feb 2012 23:23:01 GMT

Coupling in object-oriented software indicates the level to which classes are reliant upon each other. A tightly coupled system is usually harder to maintain and modify than a loosely coupled one. The Law of Demeter addresses a specific coupling problem.

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.