What others are saying
Here is an unsolicited letter from Miguel A. Castro. He's a
Microsoft MVP (Most Valuable Professional for C#/ASP.NET), a well-known .NET author,
.NET trainer, and a member of the International .NET Association (INETA) speakers bureau.
Quite a package you guys put together there - code and docs. You've managed to compile
for me what I've been grabbing from
various sources over a long time. I'm very impressed.
I am already a customer and I hope you have tremendous success
with the framework.
Keep up the good work!
Two editions: C# and VB
Is your preferred language C# or VB? In fact, it does not matter because the
Design Pattern Framework comes in two editions: C# and VB.
Their contents are the same -- each with
source code in their own language: the C# edition comes with
100% pure C# source code and
the VB edition comes with 100% pure VB source code.
What do I get with the Design Pattern FrameworkTM?
In fact, our latest Design Pattern Framework 4.0 is 9 packages in one --
each filled with information and source code you will not find anywhere else --
and each working together to empower your applications and your career. They are:
| 1.|| 69 Comprehensive .NET 4.0 Design Pattern Projects|
| 2.|| 23 Valuable UML Diagrams in Visio format|
| 3.|| Printable PDF document with all GoF Patterns|
| 4.|| 3-Tier Pattern Architecture |
| 5.|| E-commerce ASP.NET MVC Pattern Application with Areas, Testing, DI, Moq|
| 6.|| E-commerce ASP.NET Web Forms Pattern Application with Routing, EF|
| 7.|| E-commerce Windows Forms Application with MVP|
| 8.|| E-commerce WPF Reference Application with MVVM|
| 9.|| E-commerce Silverlight Application with MVVM, RIA Services, MEF|
Design Pattern Framework 4.0, our latest release, has been enhanced significantly with the lastest
insights on how to build a 3-tier .NET pattern architecture based on the .NET 4.0 platform.
These include ASP.NET MVC 2 (with Areas, Testing, Dependency Injection, Mocking), Silverlight 4 (with MVVM, RIA Services, Managed Extensibility Framework),
Entity Framework, greatly improved ADO.NET Data Access, and more...
Let's review each of the 9 packages in more detail.
9 products in one
1. 69 Comprehensive Gang of Four .NET 4.0 Design Pattern Projects
Have you ever wondered how useful it would be to have dozens of
design pattern source code projects available at your fingertips? Yes, Google and Bing
are just a few clicks away, but the results require you to wade through numerous
result pages before you may find your answer -- mostly without meaningful or useful sample code.
Not so with the 69 ready-to-run Design Pattern projects. Well organized in a
single Visual Studio .NET solution, you have the following code available at your fingertips.
- 23 Structural Gang of Four design patterns
- 23 Real-World Gang of Four design patterns
- 23 .NET 4.0-Optimized Gang of Four design patterns
A total of 69 design pattern projects -- each clearly named and within easy reach.
How easy? Simply create a shortcut to our master .NET Solution on your desktop
and you're ready to explore all 69 elegant software solutions.
And, of course, every project comes with 100% pure source code!
Your desktop shortcut(s) will look like this:
Design Pattern shortcuts:
Double click the shortcut and all 69 pattern projects are instantly available:
Design Pattern Solution Explorer:
100% pure source code for the best learning experience:
Visual Studio .NET code editor:
69 design pattern projects
2. 23 Valuable UML Diagrams in Visio format
Many of you have asked about the Visio templates for the UML diagrams
of the 23 Gang of Four Patterns. We are
now including these in the Design Pattern Framework!
23 Visio templates in all: one for each of the Gang of Four patterns.
Use these for your study of design patterns or when discussing
patterns with your colleagues. Or perhaps you want UML
printouts of commonly used patterns on your office wall.
Whatever your need, you have all UML diagrams available in a format you can
23 Design Pattern UML Diagrams in Visio:
23 UML diagrams
3. Printable PDF document with all 23 GoF Patterns
Many developers have requested that the design pattern details
be made available in some printable format. We're pleased to let you know that
with the Design Pattern Framework you're getting a printable PDF
pattern reference guide.
In this 88-page document you will find important details on each of the
the 23 GoF patterns: definition, frequency of use, UML diagram, and
participating classes. This document goes hand in hand with the
aforementioned 69 design pattern projects. A very powerful combination indeed.
It is one thing to understand design patterns. It's an entirely different thing
to understand exactly when and where you apply these patterns.
Books on design patterns mostly explain the mechanics of the patterns rather than
their usage. We are pleased to announce that this PDF document provides you with this
Each of the 23 patterns includes:
1) when and where in .NET do you apply the design pattern, and
2) where does Microsoft use design patterns in its own .NET Framework.
This information, in combination with so much useful source code, is
not available anywhere else.
Printable PDF Design Pattern Document
printable pdf document
4. 3-Tier Pattern Architecture
Included in the Design Pattern Framework 4.0 is an unique e-commerce reference application
named Patterns in Action. It is built on a 3-tier pattern architecture
using advanced design patterns and best practices.
Patterns in Action shows in great detail (100% source code)
how to build a robust 3-tier pattern architecture that supports any UI platform
(i.e. the Presentation tier).
Each UI communicates with the application via the exact same WCF service layer
(the Application Facade Pattern). You will receive 4 completely functional
applications with these UIs: ASP.NET Web Forms, ASP.NET MVC, Windows Forms, and WPF. See screenshots below.
ASP.NET MVC Presentation Tier
ASP.NET Web Forms Presentation Tier
Windows Forms Presentation Tier
WPF Presentation Tier
Did you notice how different these applications are? Yet, they are:
- Built on the exact same 3-tier pattern architecture,
- Consume the exact same WCF services, and
- Use the exact same database.
: A comprehensive Silverlight Patterns
Reference Application is also included.
You will discover MVVM, RIA Services, Entity Framework, and MEF pattern architectures.
3-tier pattern architecture
4 UI Platforms
So what exactly is 'Patterns in Action' ?
Patterns in Action is a real-world, e-commerce
4.0 .NET reference application that clearly demonstrates
when, where, and how design patterns are applied in
today's modern application design.
Of course it comes with 100% source code -- nothing is
Patterns in Action includes features that are common
to modern e-commerce application. For example, users can
browse a product catalog, view products and product details,
add items to a shopping cart, remove items from a shopping cart,
change quantities, calculate and recalculate subtotals and totals.
Also included is an administrative module from which the administrator
manages customer data and reports on customer orders with all order details.
In fact, Patterns in Action contains code
that is valuable beyond the realm of e-commerce applications.
Examples include: a
hierarchical menu system, an error logging facility, encryption routines,
business rules engine, and a system of a highly configurable data access objects (DAOs).
Below is an overview with screenshots for each of the UI platforms.
The Design Pattern Framework is very popular
Since our first release, thousands of .NET architects and .NET developers have come to rely on
the Design Pattern Framework for their programming skills. Here's why.
As a .NET developer you know the value of having access to real-world source code written by expert developers.
You study the code, internalize the best ideas, and then apply these to your own work.
Exploring master-crafted source code is the most effective way to become confident and
productive in applying patterns to your own work.
How do we know?
- We are professional developers, architects and MCSDs ourselves --
we know how we got there,
- We train developers on using design patterns.
So, we know the most effective way to learn about patterns, and
- Our website has offered design pattern source code
for many years now. Every day, we get thousands of .NET enthousiasts
like you who come here to get the necessary information
that make them succeed in their work and their career.
Developers need source code!
Here's some proof that we are the #1 .NET Design Pattern site on the Internet!
we're #1 in .NET
Using patterns to build a robust 3-tier architecture
Many .NET applications do not benefit from a robust
3-tier architecture. Instead they have all their code (UI, business logic, and data access)
in one place: the code behind.
The initial development cycle may be shorter, but in the long run you'll find
that these applications do not evolve well with changing business needs.
They are hard to maintain, nearly impossible to change, difficult to integrate
(expose as a Web Services for example),
and they do not scale very well (for when your website becomes an instant success!).
Here are some details on the 3-tier pattern architecture in Patterns in Action:
3-tier application model:
In a 3-tier model each tier corresponds directly to one of the three elements
needed in an architecture: interaction, manipulation, and storage. The three
tiers or layers are:
- Presentation layer — handles external interaction with the user
- Business layer — manipulates the information required by the user
- Database layer — stores the data handled by the system
Now, 3-tier architectures are widely accepted as a high-level best
practice approach. However, as a .NET developer additional questions remain. For example,
how is each tier built and and how do the tiers communicate with each other?
Below is a cross-section that shows some of the technologies used and
between the layers.
The right-hand-side shows some of the key design patterns
used in the reference application. Clearly, patterns
play an integral role throughout the entire 3-tier architecture.
Here are some details on the tiers and their relationships:
The PL: The concern of the Presentation Layer (PL) is to present information in a consistent
and easy-to-understand manner to the end-user. Patterns in Action includes fully functional
implementations of three UI platforms: ASP.NET, Windows Forms and WPF (Windows Presentation Foundation).
From PL to WCF: Each of the 3 UI platforms consume the exact same services
hosted under WCF. This service-oriented
model is an implementation of the Application Facade Design Pattern.
Applications designed this way have the ability to expose their Services (Web or otherwise) with no
extra work (other than configuring the WCF host). WCF is truly a powerful new platform!
From WCF to BL:
The WCF Service Layer receives messages from the PL.
It interprets the message, unpacks the Data Transfer Objects,
and orchestrates and coordinates the interaction between
Business Objects and Data Access Objects.
The Services Layer is also the place where authorization, authentication,
data validation, and database transactions are implemented.
The BL: In the Business Layer (BL) you'll
find Business objects, such as, Product,
Customer, and Order. Business Objects encapsulate business logic
in the form of business rules. Business Objects themselves have
no knowledge about databases or data persistence, which is handled by the DL.
From BL to DL: In fact, Business Objects do not
directly interact with the
Data Layer (DL).You don't ask a Product business object to save
itself and there are no Save or Load methods on the Business Objects
Instead, persistence is handled by dedicated Data Access Objects (another
Enterprise Pattern) that extract
data from the Business Objects and subsequently store it in the database.
The DL: The Data Layer (DL) handles the persistence of Business Objects.
Patterns in Action offers two different technologies: ADO.NET and LINQ-to-SQL.
In web.config you indicate which one to use.
ADO.NET implements a 'data provider factory' which uses an
abstract factory pattern and returns database specific singleton factories.
This example shows that design patterns frequently work together with other patterns.
When using LINQ-to-SQL you will see that LINQ generated Entities are mapped
to Business Objects.
Following this review, we'd like you to
walk away with the following important observation:
Have you noticed that there are no
direct interactions between the PL and the BL or DL?
In other words, the UI only interacts with the application via the Service Layer.
This is by design. The reason is that security, data validation, and
transactions are managed at the Service Layer.
The UI is never allowed to bypass these important functions. Therefore,
all communication with the application must go through this
single point-of-entry (Application Facade) which is hosted under WCF.
Building a 3-tier application structure
Once you've decided to build your .NET application following a modern,
pattern-based, 3-tier architecture, you may be asking yourself: How do I
organize and structure my Visual Studio .NET Solution and Projects?
Patterns in Action will demonstrate
exactly how this is done - again, with great documentation and
100% pure source code.
Below are 3 annotated screenshots that show the
Solution Explorer of this reference application.
The first screenshot shows the layers in the application. They
have been numbered so that they display in a logical top-to-bottom order.
Physical Layers in 'Patterns in Action':
The next screenshot shows all 21 projects. Notice
the 4 different UI platforms in the Presentation Layer (ASP.NET MVC, ASP.NET Web Forms, WinForms, and WPF).
Again, each of these UI platforms consume the exact same services in WCF, which,
in turn, rely on the same Service-, Business-, and Data-Layers (discussed below).
Projects in 'Patterns in Action':
Finally, the third screenshot shows the complete set of re-usable classes, types,
and design patterns that you will receive with your Patterns in Action solution:
Classes and other Types in 'Patterns in Action':
Here is a view of the Silverlight Pattern Architecture
with MVVM, RIA Services, Entity Framework, and MEF (Managed Extensibility Framework).
Silverlight Patterns Solution
easily adaptable applications
100% pure source code
Gang of Four Design Patterns
Patterns in Action incorporates many of the frequently used
Gang of Four patterns, including, Facade, Singleton, Abstract Factory,
Observer, and Proxy. Here are some details on how these patterns are used:
The Facade design pattern plays a key role in the application.
Not only does it enhance and simplify the design of the application, it
also makes it easy to be integrated into a larger WCF based SOA
(Service Oriented Architecture).
The WCF services are exposed as a single-point-of-entry
for any platform and any application that consumes its services on the cloud.
The ASP.NET Web Forms menu system is designed as a hierarchy with parent and child nodes.
tree structure is implemented using the Composite design pattern.
Error logging and tracing are implemented with the help of the Observer pattern.
Observer classes register themselves with the Logger and listen for
Log events. In fact, two design patterns are at play here as the Logger
class is a Singleton also.
Patterns in Action comes with a fully functional e-commerce
shopping cart. Items can be added, removed, and recalculated in the cart.
The Strategy pattern is used to swap out different strategies for
shipping charges (and can easily be extended to include
tax and insurance computations, if necessary).
Abstract Factory + Singleton
The Abstract Factory pattern solves the problem of accessing different databases.
Database specific factories are created which themselves are Singletons.
These factories allow you to change databases simply by changing an entry in
web.config. Databases supported include: MS Access, SQL Express, and SQL Server.
Proxies are surrogate objects that represent external resources that
are slow or not guaranteed to be always available. In Pattern in Action we
demonstrate database proxies and WCF client proxies. These are 'stand-ins' or
proxies for the real objects.
Enterprise Design Patterns
Since the publication of the original 23 Gang of Four patterns
additional design patterns have been 'discovered'.
Especially important are the Enterprise
Design Patterns as documented in Martin Fowler's
popular book: "Patterns of Enterprise Application Architecture".
You'll be pleased to know that
more than a dozen of these valuable patterns are included in Patterns in Action.
All this adds up to an even greater learning experience! Again, you will not find
this kind of information anywhere else -- certainly not with 100% source code!
Here is the list of Enterprise Patterns that were used to build this application.
|Enterprise Design Patterns
||Organizes business logic by procedures where each procedure handles a single request from the presentation.
||An object model of the domain that incorporates both behavior and data.
||Defines an application's boundary with a layer of services that establishes a set of available operations.
||An object that doesn't contain all of the data you need but knows how to get it.
||Saves a database ID field in an object to maintain identity between an in-memory object and a database row.
|Foreign Key Mapping
||Maps an association between objects to a foreign key reference between tables.
||An object that handles a request for a specific page or action on a Web site.
||Renders information into HTML by embedding markers in an HTML page.
||A view that processes domain data element by element and transforms it into HTML.
||Provides a coarse-grained facade on fine-grained objects to improve efficiency over a network.
|Data Transfer Objects
||An object that carries data between processes in order to reduce the number of method calls.
||Removes dependence upon problematic services during testing.
Gang of Four
enterprise design patterns
Bonus 1: Getting Started Guide
The Design Pattern Framework 4.0 comes with a lot of information.
To help you get started quickly and navigate throught the different
pieces of the Framework we now include, as a bonus, an easy-to-read Getting Started guide.
This guide will get you up and running quickly and, before you know it, you'll
be joining the ranks of expert NET architects that live the .NET 4.0 pattern lifestyle.
Here are the sections included in this guide:
- Setup and Installation
- Database Configuration
- Projects and E-books in the Framework
- Learning about Design Patterns
- What are Design Patterns
- Exploring Design Patterns
- Applying Design Patterns
Bonus 1: Getting Started Guide
Bonus 2: SOA and Messaging Design Patterns
As a bonus you will receive a rich set of SOA and Messaging design patterns. These patterns
play a central role in the WCF projects. Patterns in Action contains two project
types that are built on WCF:
- WCF Hosting, and
- WCF Services
The WCF Hosting projects manage singleton resources, that is, resources of which just one
instance can exist, such as, a databases or customer images.
The WCF hosting options are configured in the web.config file.
These projects usually have very little code.
On the other hand, the WCF Service projects are usually 'code-rich' and, in Patterns in Action
contain numerous examples of SOA patterns
that help you design clean, message-oriented APIs. Below is an example of such an API which is the entire service API for
Patterns in Action.
Notice how incredibly simple it is. Each of the 3 UI platforms (ASP.NET, WinForms, WPF)
are clients to the exact same API. Quite impressive.
/// Interface for Patterns in Action public services.
[ServiceContract(SessionMode = SessionMode.Required)]
public interface IActionService
TokenResponse GetToken(TokenRequest request);
LoginResponse Login(LoginRequest request);
LogoutResponse Logout(LogoutRequest request);
CustomerResponse GetCustomers(CustomerRequest request);
CustomerResponse SetCustomers(CustomerRequest request);
OrderResponse GetOrders(OrderRequest request);
OrderResponse SetOrders(OrderRequest request);
ProductResponse GetProducts(ProductRequest request);
ProductResponse SetProducts(ProductRequest request);
CartResponse GetCart(CartRequest request);
CartResponse SetCart(CartRequest request);
Another take-away here is that WCF Service APIs are not object-oriented.
Instead, they are message-oriented, in which each method call represents a complete,
SOA and Messaging patterns make extensive use of
Data Transfer Objects (an Enterprise Pattern).
SOA is a relatively newcomer to the pattern scene, but SOA patterns
have been evolving rapidly. You will find several popular ones implemented in the
Patterns In Action reference application (as an extra bonus). These include:
- Application Facade design pattern,
- Document-Centric design pattern,
- Request-Response design pattern,
- Idempotent design pattern,
- Message Router design pattern, and
- Private Identifier design pattern
Of course, everything comes with 100% source code and
extensive documentation for a rich learning experience.
Bonus 2: SOA Patterns
WCF Services API
Bonus 3: Head First Design Patterns
If you have been following what is going on in the world of design patterns then you know that the
Head First Design Patterns book
has created quite a stir. It is one of those rare gems that has the ability to make
something as complex as design patterns, easy and fun to learn.
See for yourself and check out the reviews on Amazon or bookpool.com.
This book is targeted at Java developers and comes with code samples in Java. We all know that
Java is similar to C# but the samples use Java types and Java packages
which makes the code all but irrelevant for .NET. Examples are:
Swing, Applets, Observer/Observable types, Java I/O classes, and Java RMI (remote
method invocation). It's hard to study these patterns and be
concerned about subtle, and not so subtle, language and platform differences.
We are happy to inform you that as an extra bonus the Design Pattern Framework
includes a complete set of Head First Design Patterns in C# and/or VB.
You'll get a total of 46 Head First Design Pattern projects nicely packaged in an easy to use .NET solution.
Simply create a shortcut on your desktop, double click, and all source code projects are available at your fingertips.
Head First Design Patterns for .NET
The Head First book itself does not reference the Java code samples which makes it hard
to link the samples back to the appropriate pages in the book.
This is why we are including a reference document that
associates each .NET project back to the appropriate page number
where the topic of the pattern begins. This document also
highlights the differences between Java (i.e. the book) and the .NET
implementations of these patterns. So, snuggle up in your favorite chair with this book and the
.NET code samples and make learning design patterns a fun
Head First Reference Document
Bonus 3: Head First Patterns
The benefits are clear
As you can see, the Design Pattern Framework is a unique product.
It has the information you need to make informed decisions
about when, where, and how to apply proven design patterns.
This is the kind of product that will change your outlook on development
as you start incorporating patterns confidently and comfortably in your
The benefits of design patterns are clear: your
applications will be easier to maintain, easier to support,
and they will perform better. Furthermore, your applications
will be more flexible, more adaptable, more manageable, and more scalable.
And, last but not least, your customers and your boss are going to be delighted!
The Design Pattern Framework truly is an investment in your success.
There is no comparable product. We urge
you to order your own copy and get started right away.
What do you have to lose for just $79?
Another unsolicited letter from a delighted .NET developer.
Your Framework is excellent. I have been trying to learn patterns for a
couple of years with very little success but this has worked wonders
in a couple of days and I am up to speed!
Freelance .NET Developer
Which of these benefits of the Design Pattern Framework
could you use to enhance your career?
- Write programs that evolve easily with changing business needs
- Increase maintainability of existing applications
- Apply and combine patterns to build scalable, 3-tier applications
- Appreciate how design patterns are integral to modern architecture
- Be comfortable with the vocabularly of expert designers
- Discuss intricate architectures with your team members
- Confidently present patterns and their benefits to business leaders
- Use best practice 3-tier pattern designs in your own work
- Reuse patterns to common elements of enterprise solutions
- Understand that patterns lead to design and architectural success
- Gain a deep understanding of how expert developers solve real-world problems with design patterns
and so much more...
Choose your favorite edition: the C# edition or VB edition. Or both!
You're just a couple of clicks away from your own Design Pattern Framework.
Order now and within minutes you'll be exploring your own copy of
these valuable patterns and practices.
60 Day risk-free money-back Guarantee
Your satisfaction is 100% guaranteed! If, after you have explored
the materials, you feel that the Design Pattern Framework 4.0 is
not going to improve your .NET applications, then please contact us
within 60 days
of the date of your purchase and receive a full refund.
Ordering is easy. Select the edition you want and click the 'Order Now' button.
Pay with any credit or debit card with Paypal (there is no need to setup a Paypal account).
Following payment you will receive a confirmation email with your credentials.
Login and instantly download your own copy of the Design Pattern Framework 4.0.
Your password will be
valid for a full year
and allow you to download any new or updated releases during that period for FREE!
.NET Design Pattern FrameworkTM
C# Edition - single user
.NET Design Pattern FrameworkTM
VB Edition - single user
.NET Design Pattern FrameworkTM
C# + VB Edition - single user
Developing with a team?
Alternatively, if you are working with a development team it may be more cost effective
to order a 16-user license. It allows up to 16 users on
your team to use the Design Pattern Framework.
Compare these prices to formal classroom training. You'll see
that this is a very cost effective way to get your team going with
design patterns. Order details are below.
.NET Design Pattern FrameworkTM
C# Edition - 16 users
.NET Design Pattern FrameworkTM
VB Edition - 16 users
.NET Design Pattern FrameworkTM
C# + VB Edition - 16 users
Alternatively, order a site-wide license which allows
unlimited users at a single physical address to benefit from the
Design Pattern Framework.
.NET Design Pattern FrameworkTM
C# Edition - unlimited users at single site
.NET Design Pattern FrameworkTM
VB Edition - unlimited users at single site
.NET Design Pattern FrameworkTM
C# + VB Edition - unlimited users at single site
P.S.: The Design Pattern Framework is the kind
of product that you will not find anywhere else.
Remember, it comes with 100% source code.
At a small cost, you're making a big investment in your success.
It is the kind of investment that will pay you back many times over in
the next year alone.
Place your order now. And do it with confidence, because it is backed by a 100% guarantee.
Our full 60-day money-back guarantee will give you plenty of time to explore
and evaluate the Design Pattern Framework 4.0.
P.P.P.S.: If you miss this, you will kick yourself...
Design Pattern Framework 4.0 requires VS 2010 Professional or better. The free VS 2010 Express edition is not supported.
Your purchase will also include older versions of the Design Pattern Framework for VS 2003/.NET 1.1, VS 2005/.NET 2.0, and VS 2008/.NET 3.5.
By purchasing and downloading the products you
agree to the terms.
full year access
don't kick yourself