only $79

Gang of Four Patterns	Silverlight Patterns	ASP.NET MVC Patterns
Enterprise Patterns	WPF & WCF Practices	MVP Patterns
Head First Patterns	LINQ-to-SQL Practices	MVVM Patterns
SOA Patterns	Membership Practices	Entity Framework
3-Tier/N-Tier Patterns	Repository Patterns	RIA Services & MEF
App Facade Pattern	Dependency Injection	Testing, Mocking, more..

Click here to find out about easy ordering and pricing.
Otherwise, continue reading and explore the details of this valuable package.

What others are saying

Hello,

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!

Miguel A. Castro Microsoft MVP and Architect at IDesign www.idesign.net

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.

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:

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.

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:

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 work with.

23 Design Pattern UML Diagrams in Visio:

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 hard-to-find information. 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

  

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

1. Built on the exact same 3-tier pattern architecture,
2. Consume the exact same WCF services, and
3. Use the exact same database.

Update: A comprehensive Silverlight Patterns Reference Application is also included.
You will discover MVVM, RIA Services, Entity Framework, and MEF pattern architectures.


Silverlight Patterns

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 hidden.

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!

Search Google for '.NET Design Patterns'  --  see that we are #1!




Search Bing for '.NET Design Patterns'  --  see that we are #1!




What sites are developers *bookmarking* on design patterns?
Search delicious.com for '.NET Design Patterns'  --  again we are #1!

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 the communication 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.

3-tier cross-section:        

        

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 themselves. 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:

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 Solution      
with MVVM, RIA Services, Entity Framework, and MEF (Managed Extensibility Framework).      

Silverlight Patterns Solution        

        

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. This self-referencing 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).

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.

Model-View Design Patterns

The Model-View-Controller (MVC) design pattern is one of the oldest and best known design patterns (first reported in 1979). Over the years, it has been used with great success in the design of many applications (e.g Microsoft Excel).

However, over time, as more modern languages and technologies were introduced, adjustments were made to the original MVC pattern. In particular the Controller class has taken on some of the responsibilities that were originally assigned to the View class. This transition has led to the creation of a family of patterns collectively known as the Model-View patterns.

In .NET the most important MV varieties are: Model-View-Controller (MVC), Model-View-Presenter (MVP), and Model-View-ViewModel (MVVM). All of these are included in the Design Pattern Framework 4.0. Here's where you find them:

• MVC -- ASP.NET MVC Application
• MVP -- Windows Forms Application
• MVVM -- WPF Application
• MVVM -- Silverlight Appication

Model-View-Controller (MVC)
	Our new ASP.NET MVC Reference Application demonstrates MVC in all its glory!

Model-View-Presenter (MVP)
	Our Windows Forms Reference Application demonstrates why MVP is such a great fit for this platform.

Model-View-ViewModel (MVVM)
	Our WPF Reference Application demonstrates how to build MVVM into your own applications.

Model-View-ViewModel (MVVM)
	Our new Silverlight Reference Application demonstrates the MVVM pattern and best practices in depth.

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.

1. Setup and Installation
2. Database Configuration
3. Projects and E-books in the Framework
4. Learning about Design Patterns
5. What are Design Patterns
6. Exploring Design Patterns
7. Applying Design Patterns

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:

1. WCF Hosting, and
2. 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.

1. Application Facade design pattern,
2. Document-Centric design pattern,
3. Request-Response design pattern,
4. Idempotent design pattern,
5. Message Router design pattern, and
6. Private Identifier design pattern

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 experience.

Head First Reference Document

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 own work.

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?

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.

Here's how to order the Design Pattern Framework

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	$79
.NET Design Pattern FrameworkTM  VB Edition - single user	$79
.NET Design Pattern FrameworkTM   C# + VB Edition - single user	$99

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	$249
.NET Design Pattern FrameworkTM   VB Edition - 16 users	$249
.NET Design Pattern FrameworkTM   C# + VB Edition - 16 users	$299

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	$549
.NET Design Pattern FrameworkTM   VB Edition - unlimited users at single site	$549
.NET Design Pattern FrameworkTM   C# + VB Edition - unlimited users at single site	$599

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.

P.P.S.: 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.