Developing Application Frameworks in .NET [Paperback]

Xin Chen (Author)

Book Description

Publication Date: April 29, 2004 | ISBN-10: 1590592883 | ISBN-13: 978-1590592885 | Edition: 1

Application frameworks, which provide a base of common services on which applications are built, offer the benefits of extensibility, modularity, and reusability of both code and design to your applications. This book explains what frameworks are and how they fit into applications, and offers many object-oriented techniques used in application frameworks.

This book also shows you actually how to develop application frameworks through a concrete framework example called Simplified Application Framework (SAF). The SAF framework was developed by author Xin Chen in C#. It consists of common services needed by many applications, such as a class factory service, configuration service, event notification service, security service, and transaction service. This book goes into detail on each of these services to explain its benefits, as well as its design and implementation in C#. Through a discussion of each service, you will also learn about many advanced .NET techniques employed by the framework, such as .NET remoting, reflection, custom attributes, multithreading, and serviced components.

Many of the services discussed in the book also use design patterns as their blueprints. This book discusses these design patterns in-depth and shows how to implement them in a real-world scenario. Accompanying the book are the complete source code of the sample framework and sample executable projects (downloadable via the Internet), allowing readers to actually test out each framework service/component of SAF and learn about the development of frameworks, .NET technologies, and design patterns in a more interactive fashion.

Special Note This book covers .NET 1.0 and 1.1. and assumes knowledge of the .NET Framework and C#.

Table of Contents

1. Introduction to Application Frameworks
2. Dissection of an Application Framework
3. An Overview of the Simplified Application Framework
4. Class Factories
5. Caching Service
6. The SAF.Configuration Service
7. SAF.EventNotification
8. Windows Services
9. Message Queue Services
10. Authorization Service
11. Authentication Service
12. Cryptography Service 
13. Transaction Service 
14. DocumentLayer Service
15. The Workflow Service

Editorial Reviews

About the Author

Xin Chen is the founder of Xtremework, Inc. Since the inception of .NET, Xin has helped customers in a wide range of industries turn their business ideas into software products using .NET technology. Leveraging his expertise in .NET and enterprise application integration, Xin has also worked with several technology leaders, such as Microsoft and Accenture, to bring winning solutions to their customers. When not working overtime, Xin enjoys reading books, writing books, and resting. He is the author of BizTalk 2002 Design and Implementation (Apress, 2003). Xin Chen earned a master's degree in statistics from Columbia University and is currently living in New Jersey.

Product Details

• Paperback: 392 pages
• Publisher: Apress; 1 edition (April 29, 2004)
• Language: English
• ISBN-10: 1590592883
• ISBN-13: 978-1590592885
• Product Dimensions: 9.3 x 7.1 x 0.8 inches
• Shipping Weight: 1.4 pounds (View shipping rates and policies)
• Average Customer Review: 4.4 out of 5 stars  See all reviews (10 customer reviews)
• Amazon Best Sellers Rank: #990,055 in Books (See Top 100 in Books)

More About the Author

Xin Chen is entrepreneur working with various internet startups in both China and US. Xin is passionate about internet and mining interesting data through the web.

Customer Reviews

Most Helpful Customer Reviews

16 of 17 people found the following review helpful:

4.0 out of 5 stars Frameworks are really important!!!, July 28, 2005

By 

Yankees Rule "J2EE Guy" (NY) - See all my reviews

This review is from: Developing Application Frameworks in .NET (Paperback)

This book is great for architects, though some of his designs i wasn't, personally, comfortable with!

Anyway, the author sets the groundwork in `how to' on building frameworks. First few chapters are excellent insight on why we need frameworks and talks about different useful strategies.

But i did find couple of places where i had to refactor it for better usability...

- Class Factories: i was really uncomfortable the way Class factories were implemented in this book by the author. For e.g. he expects the developer to provide string based value...which i personally feel is error prone...

Instead of calling

pf = (ProductFactory)SAF.ClassFactory.GetFactory("ProductFactory-A ");

i feel you should rather pass

pf = (ProductFactory)SAF.ClassFactory.GetFactory(typeof (ProductFactory));

now on the server side, whatever is the current implementation of the abstract class ProductFactory is available, it would be passed back to the client...so the configuration file would change from

<Class name="ProductFactory-A"

type="TestConcreteFactory.ConcreteProductFactory,TestConcreteFactory"/>

to

<Class name="<

>.ProductFactory"

type="TestConcreteFactory.ConcreteProductFactory,TestConcreteFactory"/>

all the server has to do is use FullName property on the type just passed to it and look into the configuration file for it.

this way, developers don't have to look around for what concrete implementation is available..

[Only drawback is that we would only have one concrete implementation available, but u r not restricted to extend it by passing additional parameters]

- Caching: Caching design in this book is one of the best designs I have ever seen. The author uses XML to store the cached objects in hierarchical structure. It solved almost all of my caching problems, like breadcrumbs on web-pages, which became part of our web framework now, user preferences, organization preferences [user can belong to multiple orgs] was also solved by this design.

But there was one very important thing that the author didn't mention was expiring stale objects in cache collection.

The easiest way to expire data is to calculate its ideal time. We could create another thread, which would interrogate each object in the cache collection for its ideal time and it would expire the least used object from the cache immediately.

Furthermore, every time an object is retrieved from the cache, we timestamp it with the latest time.

This would keep the cache from consuming insane amount of memory on the server.

I really liked other chapters too,

- Windows Service - though I rather deploy my objects in Component Services

- MSMQ - MSMQ is very useful but highly under-credited. This chapter definitely gives us more insight on how to leverage MSMQ in enterprise systems.

- Authorization/Authentication - I would say pretty good content

- Transaction - depends upon architecture of a project. If all the data intensive tasks are done in one stored procedures, then we really don't need to use Transaction services & simply rely on DB transactions, but if you have individual objects do individual data related tasks then Transactions offered by Enterprise Services are really helpful.

Nevertheless, I strongly recommend this book for all software guys.

13 of 15 people found the following review helpful:

5.0 out of 5 stars Wow!, November 16, 2004

By 

Cedric Bertolasio (Westminster, CO USA) - See all my reviews
(REAL NAME)   

This review is from: Developing Application Frameworks in .NET (Paperback)

This book really sheds light on many of the Classic Gang of Four Design Patterns and provides real world, meaningful examples to demonstrate them.

If you have ever wanted to know how to use proper object oriented techniques in .NET, this book is for you.

The book provides some very interesting approaches on extensible, practicle, and reusable code, and the samples are right on par with the typical functionality that an application framework should provide.

It is also a very clean and easy to read book, and is organized very well.

6 of 6 people found the following review helpful:

4.0 out of 5 stars Overall Good Reading, July 17, 2006

By 

Adnan Masood (Monrovia, CA, USA) - See all my reviews
(REAL NAME)   

This review is from: Developing Application Frameworks in .NET (Paperback)

As one would say that mere coders think in terms of ad-hoc one time solutions while developers and software engineers think how to incorporate these best practices in the form of an application framework. Xin Chen has done a good job explaining big picture thinking i.e. how a set of libraries or classes that are used to implement the standard structure of an application are made to collaborate in the form of a reusable framework.

I'm personally a big fan of application frameworks which provide extensibility along with good foundation support for example Rocky Lhotka's CSLA (Component-based Scalable Logical Architecture). Xin Chen does the similar job building one chapter at a time. He is walking the reader through step by step building of the framework and keeping the big picture in sight. The book is divided into 15 chapters in which Xin elaborates on application frameworks, dissect them, discusses class factories, caching, configuration, windows services, message queuing, authorization, authentication, cryptography, transaction, document layer and work flow services. The author has high degree of familiarity with GOF design patterns so reader will see the degree of reusability and patterns & practices in action. Application event logging and exception handling is an inherent part of any application framework however I was disappointed to see not much discussion about it in the book. Also, during the discussion of real world business problems, author did not discuss rules engines or provide guidance about integrating dynamic logic into your framework which I strongly feel should be an integral part of an enterprise level architecture. The current business models as we know them thrive on change and we cannot isolate development designs from user's needs.

Having said that, if you are looking to build a large amount of reusable code into a framework to save development time for yourself and fellow colleagues / developers, this book will provide you enough good pointers for this purpose. Author recognizes that the frameworks cannot be built in the air and hence provided us with concrete examples. I'll also recommend reading "GOF Design Patterns", Rocky Lhotka's "CSLA.NET 2.0 (Expert C# Business Objects)" and "Framework Design Guidelines: Conventions, Idioms, and Patterns for Reusable .NET Libraries" along with this if you are serious about developing application frameworks for your enterprise.