Home > Store

.NET-A Complete Development Cycle

Register your product to gain access to bonus material or receive a coupon.

.NET-A Complete Development Cycle


  • Sorry, this book is no longer in print.
Not for Sale


  • Copyright 2004
  • Dimensions: 7" x 9-1/4"
  • Pages: 592
  • Edition: 1st
  • Book
  • ISBN-10: 0-321-16882-8
  • ISBN-13: 978-0-321-16882-5

Praise for .NET—A Complete Development Cycle

“Excellent step-by-step walkthrough of software development with .NET for architects and programmers. Great explanation of current software development methodologies, and a wealth of practical examples using current techniques.”

         —Phil Syme
             Technical Lead
             Watson Wyatt Worldwide
             Washington, D.C.

“This book takes a unique approach to integrating real-world development examples to illustrate the phases and tasks of the software development lifecycle.”

         —Jackie Goldstein
             Renaissance Computer Systems Ltd.
             and MSDN Regional Director

“In this book the authors excel in presenting all aspects of the .NET development cycle in a format accessible to the beginner, and as a primer and reference for the experienced developer. It is exemplary in its encouragement of good software engineering technique from the outset by adhering to the Unified Process. This book is not only educational and informative, but working through it is fun!”

         —Dr. Oliver Downs
             Chief Scientist, Analytical Insights, Inc.

“As a software project manager, I found this book and accompanying CD to be a valuable aid to help sort out the practical application of .NET from all the hype.”

         —Daniel Paulish
             Software engineering project manager with
             more than 20 years’ experience

.NET—A Complete Development Cycle is the first guide to combining the best software-engineering practices of the Unified Process with the ins and outs of the .NET architecture. The book begins with an overview of the principles of software engineering and then introduces Microsoft technologies such as Visual C#, Windows Forms (WinForms), ADO.NET, and ASP.NET.

Central to this practical guide is a case study developing a working imaging application. As the authors lead readers through the complete lifecycle of this .NET development project, they teach effective software-engineering methodologies, including top strategies for requirements engineering, functional breakdown, design reviews, implementation, testing, and deployment. Readers will also learn how to make the most of tools such as the Unified Modeling Language (UML), GDI+, multithreading, Web Services Description Language (WSDL), Simple Object Access Protocol (SOAP), Universal Description, Discovery and Integration (UDDI), and versioning.

By actively participating in this case study, readers become working members of the development team. They use their newly acquired knowledge to accomplish tasks critical to the successful creation of the Web-based smart-client application.

Whether you are making the transition to .NET architecture or are an experienced Microsoft developer, project lead, or software quality engineer who wants to learn effective software-engineering techniques, .NET—A Complete Development Cycle is an invaluable resource. Readers will come away with the foundation needed to use .NET technologies to design and build complete applications, a solid understanding of good software-engineering practices, and a working Web-based imaging application that can easily be expanded or customized.


Source Code

Download the Source Code Files for this book:

Chapter 3
Chapter 4
Chapter 5
Chapter 6
Chapter 7
Chapter 8
Chapter 9
Chapter 10
Chapter 11
Chapter 12
Chapter 13

CD Contents

Untitled Document Download the CD Contents related to this title.


Author's Site

Click for the Author's Web Site related to this title.

Sample Content

Downloadable Sample Chapter

Download the Sample Chapter related to this title.

Table of Contents



About the Authors.

1. Introducing .NET.

The Need for .NET.

The .NET Framework.

The Common Language Runtime.

The Framework Class Library (FCL).

The C# Language.

Debugging and the IDE.

References for Further Reading.

2. Introducing Software Engineering.

Introducing Software Engineering Practices.

Choosing a Software Development Model.

Commonly Used Software Development Models.

Code and Fix Software Development Model.

The Waterfall Software Development Model.

The V Software Development Model.

The Spiral Software Development Model.

The Staged Delivery Software Development Model.

The Evolutionary Prototyping Software Development Model.

The Scrum Software Development Model.

The Adaptive Software Development Model.

The Unified Process Software Development Model.

The Extreme Programming Software Development Model.


References for Further Reading.

3. A .NET Prototype.

Getting Started.

Evaluating .NET for Windows Client Applications.

Our First .NET Application.


Implementing the SmartNotes Application.

Creating a New Project.

Modifying Form Properties.

Adding Controls to a Form.

Adding a Form to the Project.

Creating an Event Handler.

Implementing a Timer.

Visual Studio.NET: Platform of Choice.

4. Project Planning.

The Project Vision and Business Case.

The Initial Use Case Model.

Requirements Keys.

Using XML for Requirements Documents.

Project Requirements.

Initial Project Planning.

Project Management Planning.

Project Implementation Planning.

Initial Risk Analysis.

Initial Requirements Analysis and Design.

The Photo Editor.

The Image-Processing Library.

The Online Shop.

Defining Architectural Requirements.


References for Further Reading.

5. The Photo Editor Application.

The Refined Project Vision and Business Case.

Refined Requirements for Online Photo Shop.

Refined Use Case Diagram.

Refined Requirements List.

Analysis of the Photo Editor Requirements.

The photo_editor Requirement.

The error_handling Requirement.

The picture_load_and_save Requirement.

The image_crop Requirement.

The image_rotate Requirement.

The image_flip Requirement.

The image_format Requirement.

The platform_os Requirement.

Design of the Photo Editor Application.

Brief Introduction to UML Class Diagrams.

Design of the Photo Editor Application.

The Detailed Project Schedule.

Implementation of the Photo Editor Application.

The Basic Photo Editor Application.

Using Version Control.

The Exception-Handling Application Block.

Customized Exception Handling.

Loading an Image.

Scrolling and Basic Image Operations.

Refactoring of the Current Code.

Creating a Custom Control for Smooth Scrolling.

Implementation of CustomScrollableControl.

Configuring the Custom Control for Use in Visual Studio.NET.

Cropping an Image.

Rotate and Flip an Image.

Save an Image.

Unit Tests.

The NUnit Test Framework.

Unit Test Implementation.



References for Further Reading.

6. GDI+ Graphics Extensions.

Requirements for the GDI+ Extensions.

Analysis of the GDI+ Extensions Requirements.

The photo_editor Requirement.

The image_graphics_annotations Requirement.

The image_text_annotations Requirement.

Design of the GDI+ Extensions.

Using Design Patterns.

Project Management Issues.

Schedule Issues.

Reported Defects.

GDI+ Programming.

What Is GDI+?

GDI+ Namespaces.

The Basics of GDI+.

Drawing GDI+ Primitives.

The Infrastructure Implementation.

Drawing GDI+ Graphics Primitives: Lines, Rectangles, and Ellipses.

Handling Mouse Events and Interactive Drawing.

Drawing Text in GDI+.

The Region of Interest, Erase, Reset, and Apply Functionality.

Debugging and Defect Resolution.

Unit Tests.



References for Further Reading.

7. Advanced GDI+ Operations.

Advanced GDI+ Extensions.

Analysis of the Advanced GDI+ Extensions Requirements.

The photo_editor Requirement.

The image_graphics_annotations Requirement.

The image_graphics_special_effects Requirement.

Design of the Advanced GDI+ Extensions.

Project Management Issues.

Request for Additional Features.

Resolution of the Request.

Using Pens and Brushes in GDI+.

Color in GDI+: Using the RGB and ARGB Formats.

More on Pens and Brushes.

The GraphicsPath Class.

The Region Class.

Implementation of Regions, Pens, and Brushes.

Using Regions for the Frame Implementation.

Unit Tests.



References for Further Reading.

8. Dynamic Loading of Components.

Requirements for Image Postprocessing Components.

Analysis of the Image Postprocessing Requirements.

The photo_editor Requirement.

The image_brightness Requirement.

The image_contrast_and_color Requirement.

The image_special_effects Requirement.

Design of the Image-Processing Components Using Late Binding.

Design of the Language Extension Components.

Project Management Issues.

Improving Project Visibility.

Implementing Dynamically Loadable Image Postprocessing Plugins.

Late Binding and Reflection.

Adding a PictureBox for Previewing Image Operations.

Implementation of a TrackBar Control.

The Language-Independent Plugin Implementation.

Unit Tests.

The Contrast Plugin Unit Test.

The Color Plugin Unit Test.

The Red Eye Plugin Unit Test.



References for Further Reading.

9. Accessing System Resources.

Refining Requirements for 3D Text Display.

Three-Dimensional Rendering Technologies.

GDI+ and DirectX.


Software versus Hardware Rendering.

Analyzing User Interface Needs.

Using OpenGL.NET.

Rendering Three-Dimensional Text with OpenGL.

Three-Dimensional Text DLL Interfaces.

Adding 3D Text to the Photo Editor Application.

The 3D Text DLL Extension.

Using PInvoke to Integrate the 3D Text DLL into .NET.

First 3D Text: A Unit Test.

Implementing the User Interface.

Conclusion: Don't Reinvent the Wheel.

References for Further Reading.

10. Performance Optimization, Multithreading, and Profiling.

Requirements for Performance Optimization.

Analysis of the Editor Optimization Requirement.

Profiling the Photo Editor Application.

Optimization Possibilities and Prototyping.

Design of the Optimizations.

Performance Optimization Options.

Multithreading and Symmetric Multiprocessing.

Design of the Multithreaded GUI.

Project Management Issues.

Relation of Project Scope, Cost, Quality, and Time.

Early Delivery Possibilities.

Other Actions.

Multithreading and Optimization Implementation.

Prototyping Solutions for Performance Optimization.

Implementing the Contrast Plugin Using Pointer Arithmetic for Pixel Access.

Multithreading Implementation to Increase GUI Responsiveness.

Using Thread Pools and Locks.

Unit Tests.



References for Further Reading.

11. Building the Web Application with ASP.NET.

Online Store Requirements.

Analyzing Interfaces and Activities.

The XML Product Catalog.

Online Store Activities.

Web Forms.

Breakdown of the Code Modules.

The Product Parser.

The Shopping Cart.

Web Forms.


Implementation of Online Photo Shop.

Creating a New Web Application.

Parsing the XML Product Catalog.

The Online Shop Portal.

The Shopping Cart.


Reference for Further Reading.

12. Security and Database Acccess.

Secure Checkout.

Integrating Externally Supplied Software.

Validation of Externally Supplied Software Products.

E-mail, Password, Credit Card: Creating a Customer Profile.

User Interfaces.

Database Records.

Tax and Shipping.

Finalizing an Order.

Secure Web Applications.




Database Access with ADO.NET.

Putting It All Together.

Creating the Data Source.

The Data Access Layer.

The Database Singleton.

The Login Page.

The Checkout Form.

No Longer Under Construction.

References for Further Reading.

13. Product Release.


Options for Distributing .NET Applications/

Creating a Setup Program.

Deploying Web Applications.

Online Photo Shop Installation Notes.

Integration Test.

Test Automation.

Creating a Test Book.

Requirements Tracing.

Software Maintanance.

Change Request Management.

Maintenance Strategies.


Project Planning.

Requirements Refinement and Customer Feedback.


Use of Unified Modeling Language and Design Patterns.


Automated Testing.

Error Handling through Exceptions.

Designing for Extensibility.

Code Reuse.

References for Further Reading.



What is the Purpose of This Book?

The purpose of this book is to introduce and explain to the reader the practical application of software development with Microsoft .NET technologies (based on Visual Studio .NET 2003), state of the art tools and good software engineering practices on the example of a real life project. During the course of this book an entire project life cycle of an Online Photoshop project is shown. The reader, as part of the project team, is integrated into the development team and is required to contribute to the success of the project with his/her own task assignments.

The project starts with a basic application and through moving forward to new iterations of the project, the difficulty of the addressed requirements gradually increases, starting with the design of simple forms and advancing to implementation of multithreaded algorithms and the development of the capability to upload pictures to order prints or customized merchandise.

The entire product development cycle including wrap up, maintenance strategies and best practices for the Online Photoshop project is discussed. Therefore each chapter starts with an explanation of the theory necessary to complete the specific development iteration corresponding to that chapter.

Readers just interested in either the software engineering or the programming related sections will find the icons useful that indicate the beginning of each programming and software engineering related sections throughout the book. The explanation of the theory at the beginning of each chapter enables us to show the reader the connection between the theoretical knowledge of .NET software development and its practical application within a real life project. This practical application of the theory is reiterated piecewise throughout the book. The successful completion of the reader-assigned tasks can be verified by checking the readers' implementation against the sample solution of each chapter that is provided on the CD ROM.

In addition, the extensive references sections provided at the end of each chapter will be a valuable help for readers that would liked to further explore topics of particular interest.

Who Is This Book For?

Because of its unique combination of software engineering theory and its practical application within a real life project, .NET—A Complete Development Cycle is valuable and targeted towards readers of the following areas:

  • Software Engineers
  • Students of Computer Science or related fields
  • Team Leads, Project Leads and Project Managers
  • Software Quality and Software Process Engineers
  • All readers within the target audience will profit from this book in many different ways. The greatest benefits will be experienced by readers of the target audience that are new to Microsoft .NET technology and/or readers that are interested in the theory and practical application of the Software Engineering Process within a real project, including the use of best practices. The practical approach of this book enables readers to learn the theory upfront and then apply the gained knowledge immediately within the same chapter to the sample project. In case the reader wants to further explore some specific subject, he or she can do that by simply using the provided references as a starting point.

    Although no knowledge of a particular programming language is required to work with this book, a basic understanding of object-oriented programming as well as some programming experience will be helpful for readers that intend to follow the implementation sections of the Online Photoshop.

    How Is This Book Structured?

    This book is structured like a real life project. The entire lifecycle of the Online Photo Shop is shown during the course of this book. Because of this structure each chapter of the book corresponds to an Iteration of the Unified Process (except chapters 1 and 2, which introduce the theory necessary to get the project started) which is the software development process of choice for this project.

    We differentiate between the software engineering sections (which are more theoretical) and the programming sections with unique icons. Although it is recommended to read through all sections of the book, this structure enables readers just interested in either the Software Engineering or the Programming parts to skip over the sections that are not of interest. Furthermore in the beginning of each chapter the current phase and iteration of the project within the Unified Process is shown to the reader. Within each chapter an icon indicates to the reader at which point a certain workflow within the project starts. This structure enables the reader to exactly determine on which phase, what iteration and which workflow the project is worked on at any time during the course of the project. In addition it should be mentioned that, for the convenience of the reader, the sample solution for each chapter is provided on the CD that is coming with this book.

    What Is Covered in This Book?

    Throughout the course of this book the reader faces the challenges of a real software project. These are analyzed, solutions for them are developed, implemented and tested using the Unified Process, state of the art tools and best practices. While proceeding through the development of the project a wide variety of .NET technologies, software engineering practices and state of the art tools are introduced and applied.

    The reader, as an integrated part of the development team, needs to contribute to the success of the project by delivering the given assignments. The required theoretical foundations are introduced before their first application and are explained whenever their usage becomes necessary, making it easy to grow into more complex requirements. The majority of the application developed involves image processing, leading to immediately visible results. The developed application is intended to be a starting point for further exploring the possibilities of .NET application development.

    In the following an outline of the content for each chapter is given:

  • Chapter 1: Introducing .NET Technology The purpose of this chapter is to introduce the features that are provided within Microsoft Visual Studio .NET 2003. Therefore, a short introduction to .NET and the main features of the .NET runtime and framework class library are explained.
  • Chapter 2: The Theory of Software Engineering This chapter serves as the actual starting point of the project that will outline and explain common Software Engineering practices. In addition the basics of "good" Software Engineering practices will be explained.
  • Chapter 3: Prototype in .NET The goal of the prototype is to develop a very simple application program to show the feasibility of building an application using .NET technology. It introduces the Visual Studio Integrated Development Environment, its application wizard, the new programming language C# and the use of Windows forms.
  • Chapter 4: Project Planning The main focus in this chapter is on capturing and analyzing requirements. Also the methodologies and practices used during the project like UML use case diagrams, coding standards, test framework, configuration management and development cycle are introduced. Furthermore XML document generation and the use of XSL stylesheets are explained in order to generate some of the project documentation automatically.
  • Chapter 5: The Photo Editor Application Like all the remaining chapters this chapter starts with the Requirements refinement and continues with the analysis of the requirements before the design is specified. Before implementation is started the detailed project schedule is discussed. Following that the implementation of a smart client Windows application, as the first component of the Online Photo Shop, is developed. Within the chapter the architectural baseline for this component is implemented, which covers loading, saving and displaying digital pictures, some basic imaging operations like rotation and, last but not least, error handling.
  • Chapter 6: Graphics with GDI+ After the Requirements Analysis and Design are finished, one of the project team members is leaving the project. Therefore strategies on how the project can recover are described. The Photo Editor is then extended by adding drawing and text features to it. The functionality is implemented using GDI+ , which is part of the .NET framework class library. Also the handling of user inputs like mouse events is demonstrated.
  • Chapter 7: Advanced Graphics Operations This chapter continues Chapter 6 and starts with the requirements analysis and the design of the new features. It is then shown how to keep the project on track when customers decide to change or add requirements during project development. In addition this chapter explains advanced features of GDI+ like graded brushes, transparent bitmaps and different fill styles to modify the images with more sophisticated graphic overlays.
  • Chapter 8: Dynamic Loading of Components In this iteration of the project it is shown how the visibility of the project status can be increased. This is very important to allow all project team members to stay focused and to identify potential problems as early as possible. Furthermore an extensibility concept for the Photo Editor using plug-ins is implemented. A set of plug-ins for different image processing operations is developed using different .NET programming languages (VB, C++, J# and C#).
  • Chapter 9: Accessing System Resources An important feature of .NET is the possible integration of unmanaged code. The need for this exists when legacy code needs to be integrated into new products or managed code cannot match the required performance. Another example is the need to gain access to system resources and hardware not exposed through the framework class library. This chapter demonstrates a solution for the latter case where access to system resources (OpenGL) is needed to allow the effective, hardware accelerated implementation of 3D rendering capabilities.
  • Chapter 10: Profiling and Performance Optimization In this chapter, after the design is defined, the basic dependency of the cost, quality, scope and schedule of a project is explained and shown. On the technical side , in order to meet performance goals, optimizations have to be made to certain imaging operations developed earlier in the book. This chapter will introduce tools for profiling .NET applications and then show how to improve execution time by using pointer arithmetic with "unsafe" code and the basics of multithreading are explained and implemented.
  • Chapter 11: Web Application with ASP.NET After the completion of the Photo Editor component the focus of the project is shifted from a smart client application to the development of the web application, the Online Photo Shop. This online shop allows customers to personalize products with their digital pictures and photographs. The chapter introduces techniques for the development of dynamic web applications using ASP.NET.
  • Chapter 12: Security and Database Access Within this chapter advanced features are added to the Online Photo Shop allowing the customers to login for the checkout process and store their personal profile on the site for later visits. Security features and database access using ADO.NET are introduced and applied to implement those features.
  • Chapter 13: Product Release The last chapter will conclude the project. Different product deployment strategies are discussed, final integration testing takes place and requirement key tracing is performed to ensure the full coverage of all project requirements. At last the project is wrapped up and maintenance strategies are discussed. This chapter will also point out practices that worked well and areas that need improvement. As a result of this discussion a list of best practices are identified.
  • How Do You Use This Book?

    This book is a guide through a real life project. The goal of the project is to develop an Online Photo Shop application using state of the art tools, good Software Engineering practices and Microsoft .NET 2003. Because of the nature of a real project the later chapters of the book depend on earlier chapters. Therefore it is recommended to read through the book in a sequential fashion. The reader will have the best learning experience by following the step by step instructions during the course of the book. Nevertheless, the reader can skip the sections he or she is not interested in. This can be done by using the icons described in the "How is this book structured" section of the Preface, as landmarks.

    When working through the book the reader has several options on proceeding. Some readers might want to follow all the implementation instructions step by step, other readers might prefer to view the sample solution of each chapter in parallel to working through the book. Both options are supported since a sample solution for each chapter is provided.

    In addition it is recommended to explore and implement further features in the areas of interest of the particular reader. This further exploration is encouraged by providing references to material that might be helpful to at the end of the chapters.

    What Is Provided on the CD?

    The CD contains the sample solution for each chapter of the book. The solution for each chapter is provided in a directory called "ChapterXX" where XX is the chapter number.

    Within the Chapters directory, the source code can be found in the subdirectories of "src". All projects and source code developed within this book can be found within the Visual Studio .NET Photo Editor solution that is part of the "src" directory. Within the source code the sample solution for tasks that are assigned to the reader are identified by "#region Task for the reader Chapter XX" (where XX stands for the chapter number). In addition to the Photo Editor solution the "src" directory contains other projects and subfolders that include utilities and tools that are used and explained during the course of the book.

    The automated generated documentation like comment web pages, defect tracking sheet and Requirements documentation that is introduced during the course of the book can be found in the "doc" subdirectory of each chapters' sample solution. Assemblies of the project are provided in both release and debug versions. The debug version can be located in the "bind" subdirectory, whereas the release version of the assemblies is stored in the "bin" subdirectory of sample solution of each chapter.



    Download the Index file related to this title.


    Submit Errata

    More Information

    Unlimited one-month access with your purchase
    Free Safari Membership