Reengineering .NET

Bradley Irby is an accomplished software architect and CTO. During his 25-year professional career, he has overseen the development of highly customized internal and customer-facing applications, including a property management system to manage the repossessed properties for Bank of America, a commercial accounting system for high-net-worth individuals, a property tax prediction system for the County of San Mateo, California, and a distributed reporting system for Chevy’s Restaurants. His other work includes projects for General Electric, Kashi, Wells Fargo, HP, and Adidas, in addition to many projects for medium-sized companies and startups such as OpenTable and Prosper.com. Bradley specializes in software reengineering and software migration, injecting quality and stability into existing legacy systems. Bradley has converted many applications from VB6, ASP Classic, and early .NET versions into more modern applications with current architecture and the latest quality approaches. His recent projects include reengineering a two million-line .NET application to use modern architectures and unit testing, resulting in a near zero defect count. He is an expert at updating applications without having to shut them down or stop feature development. Using a reengineering process Bradley developed, old applications can be updated to improve quality and satisfy existing customers, while also allowing continued feature development to keep pace with competitors and attract new customers. Bradley manages the San Francisco .NET user group and is a frequent speaker on technical software topics throughout the U.S. He holds a bachelor of Computer Science degree from the University of North Carolina and an MBA from the University of California at Berkeley.

Preface   xiii
Acknowledgments   xix
About the Author   xxi
PART I Target Architecture
1  Implementing a Service-Oriented Architecture   3
An Overview of the Service-Oriented Architecture   4
Understanding Standardized Service Contracts   6
  Interfaces   6
Understanding Coupling   12
Understanding Service Abstraction   15
Designing Reusable Services   18
Understanding Service Autonomy and Service Composability   18
Understanding Service Statelessness   19
A Service Example   24
Summary   26
2  Understanding Application Architecture   27
Working with Architectural Patterns   27
An Overview of Architectural Patterns   28
Differences Among MVP, MVC, and MVVM   29
  Model Access   30
  View Models   31
Handling UI Events   38
How Do the Patterns Work?   43
Which Pattern Should You Choose?   45
Summary   45
3  Unit Testing   47
An Example of Unit Testing   48
Creating Unit Tests   49
Writing a Test   52
Detecting Exceptions   58
Understanding the Power of Assert   61
Comparing Unit Tests to Integration Tests   61
Using the InternalsVisibleTo Attribute   62
Understanding Test Driven Development   65
Learning More About Unit Testing   65
Summary   66
4  Understanding the Dependency Inversion Principle   67
Understanding Tight Coupling   67
Implementing the Abstract Factory Pattern   74
Introducing Interfaces   79
Creating Unit Tests   82
Understanding Service Location   84
  Inversion of Control Containers   84
  Service Locator   88
  A Real World Example   90
  OnDemand Service Properties   96
  Unit Testing Advantages   99
  Final Tweaks   100
Using Dependency Injection   103
Why Is Service Location Better for Reengineering?   108
Summary   113
5  Using Test Doubles with Unit Tests   115
How Do Test Doubles Work?   115
What Need Do Test Doubles Satisfy?   116
Creating a Stub   119
  Distinguishing Between Mocks and Stubs   123
Creating a Mock   124
  A Second Mocking Example   128
  A Third Mocking Example   129
Using Mocking System Services   130
Learning More About Test Doubles   133
Summary   133
PART II Reengineering
6  Initial Solution Review   137
Analyzing the Code   138
  Basic Architecture   138
  Code Structure   139
  Database Access   140
  Data Structures   140
  External Interfaces   141
  Application Controls Versus Form Controls   142
Analyzing the General Code Structure   142
Managing Language Migration   144
Removing Dead Code   145
Using Global Variables   145
Converting Code: It’s Not All or Nothing   149
Using an Automated Code Conversion Utility   150
Using Data Access Technologies   152
  Detecting the Data Model   152
  Detecting the Data Access Pattern   154
Summary   155
7  Planning the Project   157
Managing Expectations   157
Creating the Reengineering Team   158
Identifying Development Tools and the Build Process   159
  Introducing Source Control   160
  Introducing Defect Tracking   161
  Installing and Using a Continuous Integration (CI) Server   161
Cleaning Up Legacy Solutions   162
Establishing the Foundation    163
Refactoring to Use Basic Services   164
Refactoring to Use Advanced Services   166
Reporting Progress to Stakeholders   166
Managing Communication and Training   167
Summary   168
8  Identifying Development Tools and the Build Process   169
Using Source Control   169
  Types of Source Control   170
  A Process Example: Using a Distributed System   171
  A Second Process Example: Using a Distributed System   172
  A Third Process Example: Using a Centralized System   173
Understanding the Pros and Cons of Centralized Systems and Distributed Systems   173
  Consuming Shared Code from Others   173
  Sharing Code with Others and Reviewing Changes   174
  Backing up the Code   174
  Managing Check-in Frequency   175
  Managing Merge Conflicts   175
  Managing Control   176
  A Final Word About Pros and Cons   176
Evaluating a Hosting Service   176
  Using Apache Subversion (SVN)   177
  Using Microsoft Team Foundation Server (TFS)   177
  Using Git   179
Managing Features and Defects   179
  Managing Custom Workflow   180
  Managing Agile Development   180
  Managing Reporting   180
Using a Continuous Integration (CI) Build Server   181
Using Visual Studio 2010 Developer Tools   181
  Refactoring Tools in Visual Studio    182
  Third-Party Refactoring Tools   183
Summary   185
9  Cleaning Up Legacy Solutions   187
Organizing the File System   187
Structuring the Project    189
Working with Project Categories   190
Understanding Project Types   191
  Application-Agnostic Projects   192
  Generic UI Projects   192
  Model-agnostic Projects   193
  Model-specific Projects    193
Reengineering Project Recommendations   193
  Constants   194
  Data Transfer Objects (DTO) Projects    195 
  Interfaces   196
  Services   197
  Domain Model Projects   198
  Repository Projects   199
  Controllers, View Models, and Presenters   199
Refactoring to the Solution Structure   200
  Remove Unnecessary Using Clauses   200
  Separate Unit Tests and Integration Tests   201
  Move Classes to Appropriate Projects   202
  Move Shortcuts to Libraries   202
Refactorings that Affect Logic   203
  Move Initialization Logic into the Constructor   204
  Replace Nested IF Statements with Guards   205
  Removing Access to Entity Class Constructors   210
Summary   211
10  Establishing the Foundation   213
Adding New Projects   213
Using Prism, Unity, and Enterprise Library Versions   214
Adapting the Shell   216
  Creating the IBaseView   217
  Adapting the Current Shell   218
  Adding a Shell Controller   220
Creating the Service Locator   220
Setting Up the BootStrapper Class   223
  Creating the Winforms BootStrapper   223
  Updating the Winforms Program Class    226
  Creating a WPF Application and Bootstrapper   228
  Using Alternative Bootstrapper Configurations   232
Summary   236
11  Basic Refactoring to Services   237
Using DialogService   238
  Unit Testing   242
  Refactoring for DialogService   249
  Adding Unit Tests   250
Using LogWriterService   251
  Refactoring for LogWriterService   254
Tracking Session Information   257
  Refactoring for Session Information   258
Accessing Resources the SOA Way   260
  Refactoring for ResourceProvider   264
Using a Message Aggregator   265
  Refactoring for MessageAggregator   266
Converting Static Classes   271
Refactoring Static Classes   272
Summary   273
12  Advanced Refactoring to Services 275
Using a Repository Pattern   275
  Creating a Repository with a Domain Model   283
  Reengineering Methods to a Repository   288
  Converting Existing Code to Use a Domain Model   289
  Adding Data Validations to the Domain Model   291
  Reengineering Domain Models to Use Validations   296
Using a Generic Object Manager   296
Simplifying Complex Code with a Command Dispatcher Service   303
  Refactoring for CommandLineInterpreter   313
Summary   314
13 Refactoring to a Controller   315
Using the Legacy Approach to Form Creation   316
Preparing the View   319
Introducing the Controller   320
Enhancing the Controller   322
Summary   325
Appendix Reengineering .NET Projects with Visual Studio 2012   327
Examining Source Control with Visual Studio 2012   327
Managing Parallel Development   330
Making Changes in Isolation   334
Unit Testing with Visual Studio 2012   337
Writing a Unit Test Method   338
Running the Unit Test   339
Using the Edit-and-Continue Feature   341
Using Continuous Test Runner   344
Using Fakes to Write Unit Tests for “Untestable” Code   346
Looking for Hard-to-Maintain Code Using Code Metrics   348
Looking for Code Duplicates   350
Summary   353
Index   355