Geeks With Blogs
The Ron on .NET Software Architecture Ron Garlit's thoughts and informational blogs on Microsoft .NET


“Design Patterns 100″ is a prerequisite for .NET Developers.

(Part 2 – Excerpts from July 2010 – PhillyNJ.NET Presentation)

Every .NET Architect, developer and even some business users have some understand of patterns which make up the system they want to construct just like our house discussion in Part-1.

Every profession hasw it own “LINGO”. Many have tagged that of the IT World as “GEEK SPEAK”.

When it comes to creating the software system even among the GEEKS we have our own language.

For the Architects of the IT world we talk Design Patterns (amoung other things).

So lets say we all get together with our business user to find out the requirements a software project.

The architect then starts to determine what design patterns are right for the solution as he listens to the users needs for the system.

He then needs to convey that to the developer.

This is where I’ve noticed the lack of understanding of the “LINGO” of our trade.

You see there are various design patterns.

In my case many of these revolve around a group of common Enterprise and SOA area of design patterns.

But all these have their roots in the basic 23 “Gang of Four” (GoF) patterns of which these all are made up of.

For the .NET developer he works with these patterns all the time. He just may not be aware of what pattern refers to what he is using in the .NET Framework.

So before I talk about any complex design patterns let’s look at the .NET Framework and see just what “Gang of Four” (GoF) patterns lurk beneath the covers.

Now let’s be clear about being unclear. (PUZZLED ARE WE ????)

As mentioned in Part-1 patterns are just that abstract image in the heads of many. Thus they vary slightly based on ones perception.

For example, I’m going to discuss the “Gang of Four” (GoF) patterns which group the 23 patterns into three areas. Those are the Creational, Structural and Behavioral Patterns.

However one of my favorite writers on the subject the late Steven John Metsker wrote a book called “Design Patterns in C#” which I highly recommend if you like a in depth discussion on the basic 23 patterns. He as do other authors breaks this same group down differently. Steve talks about five groups of patterns around the same 23 basics. Those are Interface, Responsibility, Construction, Operations and Extension Patterns.

In the end they are all right. It is all based on words to help form that image or pattern in the head of the person your discussing your design with.

My point here is this.

There is a lot of wiggle room here. Since we can all say the same thing in many different ways and still get the message across to one another.

Also as indicated before all patterns are made up of these basic patterns in some variation.

A classic example of this is the Provider design pattern in .NET Framework 2.0.

Although it is not a GoF pattern (it was not part of the original 23 patterns), it used throughout the .NET Framework itself.

The Provider design pattern is essentially a blending of three GoF design patterns.

It is very close to the Strategy design pattern, it makes extensive use of the Factory and Singleton patterns covered later in this series.

So many of you are wondering.

What are those patterns?

(NEXT: Design Patterns 100-Part3 – Creational Patterns)

Posted on Tuesday, May 24, 2011 8:59 PM | Back to top

Comments on this post: Design Patterns 100-Part2

No comments posted yet.
Your comment:
 (will show your gravatar)

Copyright © RonGarlit | Powered by: