Code Generation in Microsoft .NET

Table of Contents

Cover

Code Generation in Microsoft .NET

ISBN 1590591372

Contents at a Glance

Contents

Foreword by Rockford Lhotka

Foreword by Don Kiely

About the Author

About the Technical Reviewer

Acknowledgments

Introduction

How Will Code Generation Help You?
Traveling Down this Path
A Note on Language and Tools
What Does This Book Cover?

Part One - The Process

Introducing Code Generation
Exploring Mechanisms for Code Generation
Generating a Simple Program
o Creating the Template
o Running the Template
o Creating the Template
o Understanding the Benefits of XSLT Code Generation
o Running the Template
o Creating the Template
Picking the Right Mechanism
Breaking Down the Code Generation Process
o Designing Architecture
o Collecting Metadata
o Outputting Code
o Writing Handcrafted Code
o Tying It Together: Implementation and Testing
o You Have Control Over the Template
o Metadata Is a Distinct Step
o Implement One-Click Regeneration
o Embrace Handcrafted Code
o Generated Code Has Great Quality, Performance, and Maintainability
Performing Real-World Code Generation
Summary
Additional Reading
Extracting Metadata
Introducing the Process
o Using Schema Definitions Such As XSD
o Extracting Metadata from Databases Such As SQL Server
o Entering Metadata Manually
o Extracting Metadata from Web Services via WSDL
o Retrieving Metadata from External Sources
o Extracting Metadata from Design Tools Such As UML
o Extracting Metadata from Existing Applications and Source Code
Understanding XSD's Role in Code Generation
Working with SQL-92 Databases (SQL Server)
o Understanding the Target Structure
o Understanding the Tool Architecture
o Understanding Security
o Understanding SQL-92 Terminology
o Introducing the Specific Schemas
o Using Constraints
o Modifying Mappings
o Determining Stored Procedure Intent
o Retrieving Stored Procedure Recordsets
o Retrieving Identity Columns
o Retrieving Extended Properties
o Implementing Naming Delimiters
o Implementing Naming Rules
Creating Freeform Metadata
o Using Skip Attributes
o Using an XSD
Merging Metadata
Summary
Additional Reading
Outputting Code
Understanding the Elements of the Code Generation Harness
o Working with Abstract File Paths
o Providing Parameters
Examining Code Generation Mechanics
o Creating a Class
o Capping Off XSLT Code Generation
o Using the IndentTextWriter
o Creating a Class
o Winding Up Brute-Force Code Generation
o Using an Object Hierarchy
o Building a CodeDOM Graph
o Exploring Other Features
o Testing in All Target Languages
o Working with the CodeDOM
Summary
Additional Reading
Writing Handcrafted Code
Effectively Using Handcrafted Code
o Running Startup Code
o Incorporating Exception Reporting
o Using Components
o Using Utility Methods
o Using Code with Insufficient or Interspersed Patterns
o Providing Reusable Functionality with a Base Class
o Providing Class-Specific Code Functionality with a Derived Class
o Providing Debug Support
Exploring Mechanisms for Isolating Handcrafted Code
o Exploring Object-Oriented Fundamentals
o Instantiating the Most Derived Class
o Looking at an Icky, Tricky OOP Detail
o Using Validation as an Example of Overriding Behavior
o Using Derived Methods to Extend Behavior
o Using Events to Provide Behavior
Summary
Tying It All Together
Getting Into the Harness Details
o Introducing the Standard Element
o Introducing the Process Element
o Introducing the XSLTFiles Element
o Introducing the SinglePass Element
o Introducing the MultiPass Child Element
o Introducing the OutputRules Element
o Introducing the Parameter Element
o Using the XSLTProcess Directive
o Using the RunProcess Directive
o Using the CreateMetadata Directive
o Using the MergeMetadata Directive
o Using the XSLTGeneration Directive
o Using the BruteForceGeneration Directive
o Using the CodeDOMGeneration Directive
o Using the CopyFiles Directive
o Using the RunSQLScripts Directive
o Using the Nested Scripts Directive
Organizing Files via the Directory Structure
Building Project Files
o Directing the Process
o Building the FileList
o Building the File List XML
o Providing Overrides
o Running the Template
Incorporating Source Control
o Initiating Source Control Tasks
o Accessing the SourceSafe Wrapper Object
Debugging
o Debugging Generated Output
o Debugging Metadata
o Debugging Harness Directives
o Debugging Generation Harness
o Debugging Templates
Managing the Project over the Long Haul
o Understanding the Create Solution Tool
o Calling the Create Solution Tool
Summary
Additional Reading

Part Two - Code Generation in Action

Mapping Database Structure into Business Objects
Creating the Object Relation Mapping (ORM) Solution
o Simplifying ORM Mapping
o Automating the Flow of Database Structure Changes
o Creating Code Generation-Friendly Metadata
o Describing Complex Stored Procedures
o Controlling Metadata Visibility
o Overriding Inferred Details for Customization
o Setting Characteristics of Generated Code via ORM Flags
o Managing Responsibility
o Specifying the Simplest ORM Definition
o Specifying Minimal Stored Procedure Information
o Limiting Children: Avoiding the Mega-Object Problem
o Specifying Individual Properties
o Defining Special Types
o Applying Different Stored Procedure Privileges
o Generating Joined Tables
o Specifying Handcrafted Stored Procedures
o Specifying the MappingRoot
o Setting Default Privileges
o Specifying Assembly Details
Morphing ORM into Generation-Friendly Metadata
o Step 1: Creating Metadata
o Step 2: Merging Metadata
o Introducing Base Pattern Used in Steps 3-8
o Step 3: Processing ORMObjectOne.xslt
o Step 4: Processing ORMObjectTwo.xslt
o Step 5: Processing ORMBuildOne.xslt
o Step 6: Processing ORMBuildTwo.xslt
o Step 7: Processing IncorporateInfo.xslt
o Step 8: Processing ORMFilterForGen.xslt
Summary
Generating Stored Procedures
Exploring Stored Procedure Generation
Generating Retrieve Stored Procedures
o Opening the Stored Procedure with the OpenSP Template
o Closing the Stored Procedure with the CloseSP Template
o Outputting Parameters with the SPParameters Template
o Outputting Columns with the ColumnSPList Template
o Looking at the Three Templates to Join Tables
Generating Create Stored Procedures
Generating Delete Stored Procedures
Generating Update Stored Procedures
Generating SetSelect Stored Procedures
Summary
Additional Reading
Generating Middle Tier Templates
Introducing Component-based, Scalable, Logical Architecture (CSLA)
Changing the Base Architecture
Generating the Middle Tier
o Opening Declarations and Entry-Level Template
o Processing the High-Level Template
o Declaring the Class
o Outputting the Template for Business Properties and Methods
o Outputting Property Procedures
o Comparing Values
o Checking Privileges
Summary
Additional Reading
Generating a WinForms Application
Reviewing WinForms Architecture
Developing Code Generation Strategies for WinForms
o Merging Additional Metadata
o Transforming Metadata for Easy UI Generation
o Adding Manual Metadata for UI Generation
o Implementing Dynamic Menus
o Working with the Generic EditForm
o Using Flow Layout in WinForms
o Handling Primary Keys
Exploring User Interface Templates
o Building the Edit Layout Template
o Building the Generated UserControl Template
Summary
Generating a Web User Interface
Reviewing ASP.NET
o Looking at the Anatomy of a Postback
o Improving Performance
o Allowing Navigation
Exploring Code Generation Strategies for ASP.NET
o Avoiding Redundant Declarations
o Locating and Naming Code-Behind Files
o Abstracting URLs to a Common Class
o Using the Abstracted URLs
o Building the URL Abstraction Classes
Walking Through ASP.NET Templates
Summary
Additional Reading
Establishing Perspective
Selling Code Generation to Management
Investigating Upcoming Features
o Storing .NET Types
o Running .NET Code
o Using XML Data and XQuery
o Exploring Code Snippets
o Refactoring
o Looking at Edit and Continue
o Exploring Generics
o Splitting Code with Partial Classes
o Using Flow Layout for WinForms
Envisioning the Future
o Sharing Templates and Frameworks
o Standardizing Metadata: The Easy Part
o Standardizing Runtime Application Interfaces: The Hard Part
o Providing Tools for Each Step
o Marking Generated Code Files
o Supporting a Standard Hash Mechanism
o Providing an XSLT Jump to Template at Design Time
o Supplying a Template-Based Strongly Typed DataSet
o Enhancing the CodeDOM
o Refactoring Code and/or Snippets to Templates
Building New Paradigms
Going Forward
Summary

Appendix A: X-Survival

Starting the XML Basic Training
Introducing Elements
Introducing Attributes
Introducing XML Rules
Handling Special Characters
Introducing Whitespace
Working with Minimal Feedback
Surviving Namespaces
Dealing with the XSD Drill Sergeant
Understanding Key XSD Nodes
Introducing Cardinality
Introducing Compositors
Validating XML in .NET
Using the Target Namespace
Editing X-Files in Visual Studio
The Commando's Guide to XSLT
Using Named Templates
Using Match Templates
Passing Parameters
Executing Conditionally with xsl:if
Branching with xsl:choose
Looping with xsl:for-each
Understanding Context
Outputting Literals
Outputting Tokens with xsl:value-of
XPath Marks the Spot
Understanding Context
Using Location Paths
XSLT and XPath Reference
Additional Reading

Appendix B: Dissecting the Metadata Extraction Tools

Converting XSD into Friendly XML
Extracting Metadata from Databases
Exploring the Class Opening
Declaring MustOverride Methods
Implementing CreateMetadata
Looping Through All Tables
Outputting XML for Each Table
Outputting XML for Each Column
Outputting XML for Column Privileges
Outputting Check Constraints
Outputting Table Constraints
Outputting Primary Key Information
Outputting Relations
Looking Back at the ExtractMetadata Class
Exploring the Constructor
Getting a Connection
Implementing MustOverride Methods
Supporting Extended Properties
Ignoring Specific Tables
Looking Back at the SQLExtractMetadata Class

Appendix C: Details of the Code Generation Harness

Building a Dynamic Data-Driven Application
Loading the XML
Popping Up the Add Menu
Adding Elements
Making a Generic Node
Displaying an Element
Executing the Script
Looking Back at the Generation Harness

Appendix D: CodeDOM Issues, Tips, and Tricks

Extending the CodeDOM
Looking at Broad Issues with the CodeDOM
Exploring Language-Specific Details
Testing in All Target Languages

Index