Finally! An easy-to-follow Guide for .NET 2.0 Architects
building Applications with Design Patterns
Announcing Design Pattern FrameworkTM 2.0
New: Includes Gang of Four, Enterprise, & SOA Patterns!
|
|
|
Attention: If you need complete
confidence working with design patterns
then this unique Design Pattern Framework
is the thing for you.
|
Here's an unsolicited letter from Yama Kamyar in California -- just one
of the many .NET developers now benefiting from the Design Pattern Framework.
Hi,
I would just like to take a minute of my time to let you know the
design pattern package for both C# and VB.NET you have offered for ONLY
$99.00 were the BEST transaction I have ever done in my career.
It is far better than buying a 600 page book and spend a 100 years learning from
it. Your package
has immediately been effective for both my business and
my career from the moment I opened it.
I love you guys!
Yama Kamyar
Yamabiz, Inc.
San Diego, California
|
|
.NET Author
and San Diego
.NET User Group
Presenter
|
And here is another unsolicited letter from Miguel A. Castro. He's a
Microsoft MVP (Most Valuable Professional for C#/ASP.NET), a well-known .NET author,
and a member of the International .NET Association (INETA) speaker bureau.
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 this. Keep up the good work!
 |
 |
Miguel A. Castro, President
Infotek Consulting Group, Inc.
New Jersey, USA
www.infotekcg.com
|
Two editions: C# and VB.NET
Is your preferred language C# or VB.NET? It really does not matter because the
Design Pattern Framework comes in two editions: C# and VB.NET.
Their contents are the same -- the difference is that each comes with
source code in their own language: the C# edition comes with
100% pure C# source code and
the VB.NET edition comes with 100% pure VB.NET source code.
What do I get with the Design Pattern FrameworkTM?
In fact, the Design Pattern Framework is 4 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 2.0 Design Pattern Projects |
| 2. | 23 Valuable UML Diagrams in Visio format |
| 3. | Printable PDF document with all GoF Patterns |
| 4. | E-commerce ASP.NET 2.0 Pattern Framework with SOA! |
Let's look at each of them in more detail.
1. 69 Comprehensive Gang of Four .NET 2.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
is just a few clicks away, but Google 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 2.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:
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're pleased to inform you that these are
now included in the Design Pattern Framework!
23 Visio templates in all: one for each of the Gang of Four patterns.
Use these while you study 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:
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 happy to let you know that
with the Design Pattern Framework your are now getting a printable PDF
pattern reference guide.
In this 84-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.
One thing is to understand design patterns. It's a whole different thing altogether
to understand exactly when and where you apply these patterns.
Books on design patterns mostly stress the mechanics of the patterns rather than the usage and the
application of the patterns. This PDF document provides you with this hard-to-find information.
Each of the 23 patterns has 2 new sections:
1) When and Where in .NET applications do you apply the design pattern, and
2) Where has Microsoft used the design pattern to build .NET Framework.
This information, in combination with so much useful source code, is not
available anywhere else.
Printable PDF Design Pattern Document
4. E-commerce ASP.NET Pattern Framework
As a 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 undoubtedly
the most effective way to build confidence and become
productive in applying patterns to your own work.
How do we know?
- We are professional developers, architects and MCSDs ourselves -- and
we know how we got there.
- We train developers in the use of design patterns.
So we know the most effective way to learn about patterns.
- Finally, our website has offered design pattern source code
for several years now. Every day, we get thousands of developers
like you who come here to get the necessary information
that will make them succeed in their work and their career.
Developers need source code!
Here's some proof that we are the #1 Design Pattern site on the Internet!
Our website offers free structural and real-world C# source code samples
for the Gof Design Patterns, but where do you go to find a real-world application that
shows how design patterns are really applied?
You won't find in pattern books. Many explain patterns with code samples that
include objects with names like Foo, Bar, and Demo -- not objects
that are relevant to your application domain.
You won't find it on the Internet either: nobody in his right mind is going to
publish the source code of their successfully architected application on the Web.
Clearly, you're in a catch-22 situation when it comes to finding
the real-world sources you need to succeed. To solve this dilemma
we are pleased to announce that the
Design Pattern Framework includes what many developers have been waiting for:
a real-world ASP.NET 2.0 e-commerce
reference application. Like everything else in this package,
the entire application comes with 100% pure source code.
This great resource has been architected from the ground up using
the most relevant and the most powerful design patterns.
It offers a unique glimpse into the world of modern application architecture
in which design patterns play an integral role.
This e-commerce web application has been named Patterns in Action!,
and, as its name implies, there is nothing theoretical here -- it's a
real-world .NET 2.0 web application in which you find design patterns
as they are used in successful business applications.
So what exactly is 'Patterns in Action' ?
|
Patterns in Action! is a real-world, e-commerce
2.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 -- absolutely nothing is
hidden.
|
|
|
Patterns in Action! includes features that are common
to modern Internet e-commerce application. For example, users
will be able to 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.
It also includes an administrative module from which the administrator maintains
customer data and reports on customer orders with all order details.
Below are some screenshots.
Product Catalog and Product List
Product Details / Add to Cart
E-commerce Shopping Cart
Customer Maintenance
Order and Order Details
In fact, Patterns in Action! contains components and subsystems
that are valuable beyond the realm of e-commerce and
apply to any web-based, data driven application. Examples include: a
hierarchical menu system, an error logging facility,
a page-based performance counter, and a data access layer that, among other
things, makes it easy to switch databases simply by changing a web.config setting.
Gang of Four Design Patterns
Patterns in Action! incorporates several of the most frequently used
Gang of Four patterns like Facade, Singleton, Abstract Factory,
Observer, and Proxy. Here are some details on how these patterns are used in
the application:
Facade
The Facade design pattern plays a key role in the overall design of the application.
The facade pattern not only enhances and simplifies the design of the application itself,
but it also positions it be easily integrated into a larger Service Oriented Architecture
(SOA). As you know SOA is hot and most companies are already taking their entire
IT infrastructure in this direction.
Business objects are invoked from the UI via this Facade.
When using a Facade the code-behind is often as simple as this:
ICustomerFacade facade = new CustomerFacade();
DataGridCustomers.DataSource = facade.GetCustomers();
DataGridCustomers.DataBind();
Composite
The menu is designed as an hierarchy with parent and child nodes. This self-referencing
tree structure is implemented using the Composite design pattern.
Observer
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.
Strategy
Patterns in Action! comes with a non-persistent 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
tax and insurance computations (and can easily be extended to included
shipping charges, 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. Two databases are included: one in Access and one in SQL Server.
Proxy
In this application each customer business object has a reference to a
list of the orders that have been placed by the customer.
However, not all situations require orders; for example when displaying a
simple customer list. Only when the orders are truly needed are they loaded.
This process of just-in-time loading is called Lazy Loading and is
implemented by the Proxy object. Both Orders and Order Details are proxied.
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.
| Pattern |
Description |
| Transaction Script |
Organizes business logic by procedures where each procedure handles a single request from the presentation. |
| Domain Model |
An object model of the domain that incorporates both behavior and data. |
| Table Module |
A single instance that handles the business logic for all rows in a database table or view. |
| Service Layer |
Defines an application's boundary with a layer of services that establishes a set of available operations. |
| Table Data Gateway |
An object that acts as a Gateway to a database table. One instance handles all the rows in the table. |
| Lazy Load |
An object that doesn't contain all of the data you need but knows how to get it. |
| Identity Field |
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. |
| Page Controller |
An object that handles a request for a specific page or action on a Web site. |
| Template View |
Renders information into HTML by embedding markers in an HTML page. |
| Transform View |
A view that processes domain data element by element and transforms it into HTML. |
| Remote Facade |
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. |
| Service Stub |
Removes dependence upon problematic services during testing. |
<
Using patterns to build a robust 3-tier architecture
Many .NET applications today do not benefit from a robust
<3-tier architecture. They are built on a simple 2-tier client/server model
in which all code (UI, business logic, and data access) has been placed in
one location: the code behind pages.
It is true that the initial development cycle may be shorter, but in the long run you'll find
that these applications do not evolve easily with changing business needs.
They are hard to maintain, nearly impossible to change, difficult to integrate (i.e. expose as a Web Services for example),
and do not scale well (for when your website becomes an instant success!).
Of course, the question arises how you go about building a pattern-based, 3-tier application.
Here is an overview of how its done 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
Below is a cross-section that shows how both Gof and Enterprise design pattern are an
integral part of the 3-tier architecture in Patterns in Action!:
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. As an ASP.NET web application
developer you know the PL very well: it is the .aspx pages with associated code behind files.
From PL to BL: The PL calls into the business layer (BL) through a service-oriented
interface which is an implementation of the facade design pattern. All data exchange
between PL and BL uses the facade because this is normally where authorization and
transactions are managed. In addition, if you wish to expose your application as a Web
Service, then the facade will make this very easy for you (A demonstration of this is included).
The BL: In the business layer (BL) behind the facade
you'll find numerous business objects, such as, Product,
Customer, and Order. Business objects encapsulate business logic
in the form of business rules, but they have no knowledge about
1.) who is using them (UI, Web Service), or
2.) where their data is stored (i.e. its persistence).
From BL to DL: It is interesting to note that the business objects
themselves do not interact with the
data layer (DL). For example, you don't ask a Product business object to save
itself -- 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) implements a 'data provider factory' which
exposes a database neutral interface. The benefit of this is that it allows
the application to easily change to another database. The 'data provider factory' uses the
abstract factory pattern and returns database specific singleton factories.
A a great real-world example of how design patterns frequently
work together.
Even if you do not purchase the Design Pattern FrameworkTM 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 DL?
In other words, the UI never calls directly into the data layer.
This is by design. The reason is that security and
transactions are usually managed in the
business layer. You cannot bypass these important functions --
therefore, all communication with the database must go through the
service facade in the BL.
Building a 3-tier application structure
Once you make the decision to model your application following a modern,
pattern-based, 3-tier architecture, you need to know how to structure and
organize your Visual Studio .NET project.
Patterns in Action! will demonstrate
exactly how this can be done - again with 100% pure source code.
Below is an annotated screenshot of the numerous projects and folders in the
Solution Explorer of this reference application. Two projects at the bottom
demonstrate SOA Patterns (Web Services and SOA Consumption) -- these are included
as a special bonus (discussed below):
Solution Explorer of Patterns in Action:
Bonus 1: Service Oriented Architecture Design Patterns
The Annotated Solution screenshot above contains two SOA bonus projects:
1) An SOA Web Service and 2) an SOA Consumer in the form of a Windows Application
which is the client to the exposed Web Services.
The Web Service demonstrates how to best program an SOA service "on top of" a Facade entirely,
that is, all Web Service methods call into the Facade only. The interface is extremely simple and
clean and no other access points are required. Both the Web Application and the Web Service
access one and the same Facade (also called a Service Layer).
Communication between Web Service and Web Service Client is well-defined and 'chunky'
(message-based) -- it makes extensive use of the Data Transfer Object Pattern (an Enterprise Pattern).
SOA is a relatively new architecture and patterns and best practices in this field are
evolving rapidly. Some early patterns are clear and these have been encoded in the
Patterns In Action reference application (as an extra bonus).
To give you an idea of what an SAO Consumer may look like some screenshots of the SOA
Windows Application Client are shown below. This is a fully functional Windows application
with a modern XP look-and-feel. Of course, everything comes with 100% source code and
documentation for you to study.
Login to the remote Web Service
Customer List with Orders and Order Details
Manage Customers with Add, Edit, Delete Functionality
Edit Existing Customer Record
Bonus 2: 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 VB.NET.
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 discussion 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
You may be interested to know that your Head First package comes with a great .NET implementation
of the MVC (Model View Controller) design pattern which by many is considered the 'grand daddy'
of all design patterns.
Model View Controller Pattern
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. In modern terminology: 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!
Javaid Karim
Freelance .NET Developer
DataByte Computing
London, UK
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.NET 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 these amazing patterns.
Ordering is easy. Select the edition you want and click the 'Buy Now' button.
Following payment you will receive an email with your password.
Use it to login to our product download area and
instantly download your own copy of the Design Pattern Framework.
Your password will be
valid for a full year and allow you to
download any new or updated releases during that period for FREE!.
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.: The low price of just $79 is a special introductory offer
which may change at any time.
You can lock-in this introductory price by ordering now!
P.P.P.S.: If you are not planning to take advantage of the
Design Pattern Framework, then you're not going to get the ultimate benefits
either -- better code, better applications, a better career, and a better
lifestyle.
P.P.P.P.S.: If you miss this, you will kick yourself...
Note: because this product comes with 100% source code no refunds are
given. By purchasing and downloading the products you
agree to the terms.