The Three-Part Structure of This Book

Microsoft .NET is a rich framework with hundreds of interesting nooks and crannies. For the computer author, this presents a unique danger: it's all too easy to become distracted with a subset of intriguing features and write a whole book without delving into the real core issues. This book is designed in three logical parts to avoid this danger.

Part I: Key Technologies

The first part of this book introduces each .NET technology from a distributed programming point of view. To keep the book relentlessly in focus, each chapter opens with a section that explains the role this feature plays in a distributed system. As a side effect, many interesting aspects of .NET don't appear in this book everything from custom controls to file I/O. In return, the book makes room for a more comprehensive look at enterprise application issues. Here are some of the topics explored:

• Understanding components and component hosts

• Bridging the gap to other platforms with XML and XML Web services

• Communicating between distributed components with .NET Remoting

• Developing a data-transfer plan and handling concurrency issues with disconnected data

• Improving responsiveness with multithreaded clients and handling contention and synchronization issues

• Creating thread pools and Windows services

• Using Message Queuing for asynchronous, decoupled communication

• Using COM+ component services to enable transactions, JIT activation, object pooling, and more for your components

The chapters in the first part of the book include sparse code examples that focus on concepts rather than toy applications, which would only dilute the content. Instead, where appropriate, you are directed to a full example in the case study portion of the book (Part III).

Part II: Developing an Architecture

The second part of this book considers application architecture: how to build the parts of a distributed application so that they will perform reliably and can scale to support large numbers of clients. These are some of the topics covered:

• The performance limitations of object-oriented design

• The fundamentals of stateless programming

• The best way to transport data, communicate errors, and monitor the performance of your application

• How to design a database for optimum performance and how to code against it without breaking encapsulation

• How to use encryption and secure your code from the transport level to the application code

• How to manage distributed application deployment by using self-up-dating applications and XML Web services

Part III: Case Studies

The final part of the book presents several complete case studies that show you how to integrate the .NET technologies discussed in the first two parts of the book into a distributed application. The following three examples are considered:

• Invoicer.NET

  Invoicer.NET coordinates the sales of employees in the field. The interesting part of this example is that it shows a phased migration path from a "traditional" approach using Microsoft Excel and Microsoft Access to a .NET solution, without requiring a full rewrite. This case study also tackles considerations for dealing with "disconnected" systems.

• Transact.NET

  Transact.NET is an order-fulfillment system that shows the key techniques to integrate XML Web services and Message Queuing in order to provide real-time notification. XML Web services provide the client order interface, and Message Queuing is the backbone that delivers notification messages.

• SuperCompute.NET

  SuperCompute.NET is a work-request application that performs requested tasks asynchronously and lets clients pick up the results later. It demonstrates how distributed application architecture allows clients to harness the CPU power of a server.

Of course, the case studies are not complete, read-to-release professional applications. Instead, each case study includes just enough code to show a well-designed solution framework for a common problem scenario. You can enhance these frameworks by adding additional security, performance optimizations, or additional features (particularly in the client applications, which lack the niceties that most users expect from a Windows GUI). Ideally, the case studies will show you how to choose and combine different .NET technologies and get you started with the best practices for .NET solution architecture.

The final chapter (Chapter 19) points you to a few interesting URLs where you can download additional distributed application case studies. These case studies, which are architected by various Microsoft teams, provide best practices for ASP.NET, ADO.NET, and XML Web services. Some of them even have associated white papers on MSDN describing the design process.